include/gen/algo_gen.inl.h#

    1//
    2// include/gen/algo_gen.inl.h
    3// Generated by AMC
    4//
    5// Copyright (C) 2008-2013 AlgoEngineering LLC
    6// Copyright (C) 2013-2019 NYSE | Intercontinental Exchange
    7// Copyright (C) 2020-2023 Astra
    8// Copyright (C) 2023 AlgoRND
    9//
   10// This program is free software: you can redistribute it and/or modify
   11// it under the terms of the GNU General Public License as published by
   12// the Free Software Foundation, either version 3 of the License, or
   13// (at your option) any later version.
   14//
   15// This program is distributed in the hope that it will be useful,
   16// but WITHOUT ANY WARRANTY; without even the implied warranty of
   17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   18// GNU General Public License for more details.
   19//
   20// You should have received a copy of the GNU General Public License
   21// along with this program.  If not, see <https://www.gnu.org/licenses/>.
   22//
   23
   24
   25#pragma once
   26//#pragma endinclude
   27inline cstring& cstring::operator =(const cstring &rhs) {
   28    algo::ch_Setary(*this, (algo::cstring&)rhs);
   29    return *this;
   30}
   31
   32inline  cstring::cstring(const algo::strptr &rhs) {
   33    algo::cstring_Init(*this);
   34    algo::ch_Addary(*this, aryptr<char>((char*)rhs.elems, rhs.n_elems));
   35}
   36
   37inline cstring::cstring(const tempstr &rhs) {
   38    ch_elems = rhs.ch_elems;
   39    ch_n     = rhs.ch_n;
   40    ch_max   = rhs.ch_max;
   41    cstring &r  = (cstring&) rhs;
   42    r.ch_elems     = 0;
   43    r.ch_n   = 0;
   44    r.ch_max = 0;
   45}
   46
   47
   48inline bool algo::cstring::operator ==(const algo::cstring &rhs) const {
   49    return algo::cstring_Eq(const_cast<algo::cstring&>(*this),const_cast<algo::cstring&>(rhs));
   50}
   51
   52inline bool algo::cstring::operator !=(const algo::cstring &rhs) const {
   53    return !algo::cstring_Eq(const_cast<algo::cstring&>(*this),const_cast<algo::cstring&>(rhs));
   54}
   55
   56inline bool algo::cstring::operator <(const algo::cstring &rhs) const {
   57    return algo::cstring_Lt(const_cast<algo::cstring&>(*this),const_cast<algo::cstring&>(rhs));
   58}
   59
   60inline bool algo::cstring::operator >(const algo::cstring &rhs) const {
   61    return rhs < *this;
   62}
   63
   64inline bool algo::cstring::operator <=(const algo::cstring &rhs) const {
   65    return !(rhs < *this);
   66}
   67
   68inline bool algo::cstring::operator >=(const algo::cstring &rhs) const {
   69    return !(*this < rhs);
   70}
   71inline algo::cstring::cstring() {
   72    algo::cstring_Init(*this);
   73}
   74
   75inline algo::cstring::~cstring() {
   76    algo::cstring_Uninit(*this);
   77}
   78
   79
   80// --- algo.cstring.ch.EmptyQ
   81// Return true if index is empty
   82inline bool algo::ch_EmptyQ(algo::cstring& parent) {
   83    return parent.ch_n == 0;
   84}
   85
   86// --- algo.cstring.ch.Find
   87// Look up row by row id. Return NULL if out of range
   88inline char* algo::ch_Find(algo::cstring& parent, u64 t) {
   89    u64 idx = t;
   90    u64 lim = parent.ch_n;
   91    if (idx >= lim) return NULL;
   92    return parent.ch_elems + idx;
   93}
   94
   95// --- algo.cstring.ch.Getary
   96// Return array pointer by value
   97inline algo::aryptr<char> algo::ch_Getary(const algo::cstring& parent) {
   98    return algo::aryptr<char>(parent.ch_elems, parent.ch_n);
   99}
  100
  101// --- algo.cstring.ch.Last
  102// Return pointer to last element of array, or NULL if array is empty
  103inline char* algo::ch_Last(algo::cstring& parent) {
  104    return ch_Find(parent, u64(parent.ch_n-1));
  105}
  106
  107// --- algo.cstring.ch.Max
  108// Return max. number of items in the array
  109inline i32 algo::ch_Max(algo::cstring& parent) {
  110    (void)parent;
  111    return parent.ch_max;
  112}
  113
  114// --- algo.cstring.ch.N
  115// Return number of items in the array
  116inline i32 algo::ch_N(const algo::cstring& parent) {
  117    return parent.ch_n;
  118}
  119
  120// --- algo.cstring.ch.RemoveAll
  121inline void algo::ch_RemoveAll(algo::cstring& parent) {
  122    parent.ch_n = 0;
  123}
  124
  125// --- algo.cstring.ch.Reserve
  126// Make sure N *more* elements will fit in array. Process dies if out of memory
  127inline void algo::ch_Reserve(algo::cstring& parent, int n) {
  128    u32 new_n = parent.ch_n + n;
  129    if (UNLIKELY(new_n > parent.ch_max)) {
  130        ch_AbsReserve(parent, new_n);
  131    }
  132}
  133
  134// --- algo.cstring.ch.qFind
  135// 'quick' Access row by row id. No bounds checking.
  136inline char& algo::ch_qFind(algo::cstring& parent, u64 t) {
  137    return parent.ch_elems[t];
  138}
  139
  140// --- algo.cstring.ch.qLast
  141// Return reference to last element of array. No bounds checking
  142inline char& algo::ch_qLast(algo::cstring& parent) {
  143    return ch_qFind(parent, u64(parent.ch_n-1));
  144}
  145
  146// --- algo.cstring.ch.rowid_Get
  147// Return row id of specified element
  148inline u64 algo::ch_rowid_Get(algo::cstring& parent, char &elem) {
  149    u64 id = &elem - parent.ch_elems;
  150    return u64(id);
  151}
  152
  153// --- algo.cstring.ch.Cast
  154inline algo::cstring::operator algo::strptr () const {
  155    return ch_Getary(*this);
  156}
  157
  158// --- algo.cstring.ch_curs.Next
  159// proceed to next item
  160inline void algo::cstring_ch_curs_Next(cstring_ch_curs &curs) {
  161    curs.index++;
  162}
  163
  164// --- algo.cstring.ch_curs.Reset
  165inline void algo::cstring_ch_curs_Reset(cstring_ch_curs &curs, algo::cstring &parent) {
  166    curs.elems = parent.ch_elems;
  167    curs.n_elems = parent.ch_n;
  168    curs.index = 0;
  169}
  170
  171// --- algo.cstring.ch_curs.ValidQ
  172// cursor points to valid item
  173inline bool algo::cstring_ch_curs_ValidQ(cstring_ch_curs &curs) {
  174    return curs.index < curs.n_elems;
  175}
  176
  177// --- algo.cstring.ch_curs.Access
  178// item access
  179inline char& algo::cstring_ch_curs_Access(cstring_ch_curs &curs) {
  180    return curs.elems[curs.index];
  181}
  182
  183// --- algo.cstring..Lt
  184inline bool algo::cstring_Lt(algo::cstring& lhs, algo::cstring& rhs) {
  185    return ch_Cmp(lhs,rhs) < 0;
  186}
  187
  188// --- algo.cstring..Cmp
  189inline i32 algo::cstring_Cmp(algo::cstring& lhs, algo::cstring& rhs) {
  190    i32 retval = 0;
  191    retval = ch_Cmp(lhs,rhs);
  192    return retval;
  193}
  194
  195// --- algo.cstring..Init
  196// Set all fields to initial values.
  197inline void algo::cstring_Init(algo::cstring& parent) {
  198    parent.ch_elems 	= 0; // (algo.cstring.ch)
  199    parent.ch_n     	= 0; // (algo.cstring.ch)
  200    parent.ch_max   	= 0; // (algo.cstring.ch)
  201}
  202
  203// --- algo.cstring..Eq
  204inline bool algo::cstring_Eq(algo::cstring& lhs, algo::cstring& rhs) {
  205    bool retval = true;
  206    retval = ch_Eq(lhs,rhs);
  207    return retval;
  208}
  209
  210// --- algo.cstring..Update
  211// Set value. Return true if new value is different from old value.
  212inline bool algo::cstring_Update(algo::cstring &lhs, algo::cstring& rhs) {
  213    bool ret = !cstring_Eq(lhs, rhs); // compare values
  214    if (ret) {
  215        lhs = rhs; // update
  216    }
  217    return ret;
  218}
  219inline algo::Attr::Attr(const algo::strptr&            in_name
  220        ,const algo::strptr&            in_value)
  221    : name(in_name)
  222    , value(in_value)
  223{
  224}
  225
  226inline bool algo::Attr::operator ==(const algo::Attr &rhs) const {
  227    return algo::Attr_Eq(const_cast<algo::Attr&>(*this),const_cast<algo::Attr&>(rhs));
  228}
  229
  230inline bool algo::Attr::operator !=(const algo::Attr &rhs) const {
  231    return !algo::Attr_Eq(const_cast<algo::Attr&>(*this),const_cast<algo::Attr&>(rhs));
  232}
  233inline algo::Attr::Attr() {
  234}
  235
  236
  237// --- algo.Attr..Cmp
  238inline i32 algo::Attr_Cmp(algo::Attr& lhs, algo::Attr& rhs) {
  239    i32 retval = 0;
  240    retval = algo::cstring_Cmp(lhs.name, rhs.name);
  241    if (retval != 0) {
  242        return retval;
  243    }
  244    retval = algo::cstring_Cmp(lhs.value, rhs.value);
  245    return retval;
  246}
  247
  248// --- algo.Attr..Eq
  249inline bool algo::Attr_Eq(algo::Attr& lhs, algo::Attr& rhs) {
  250    bool retval = true;
  251    retval = algo::cstring_Eq(lhs.name, rhs.name);
  252    if (!retval) {
  253        return false;
  254    }
  255    retval = algo::cstring_Eq(lhs.value, rhs.value);
  256    return retval;
  257}
  258inline algo::Bool::Bool(u8                             in_value)
  259    : value(in_value)
  260{
  261}
  262inline algo::Bool::Bool(algo_BoolEnum arg) { this->value = u8(arg); }
  263inline algo::Bool::Bool() {
  264    algo::Bool_Init(*this);
  265}
  266
  267
  268// --- algo.Bool.value.GetEnum
  269// Get value of field as enum type
  270inline algo_BoolEnum algo::value_GetEnum(const algo::Bool& parent) {
  271    return algo_BoolEnum(parent.value);
  272}
  273
  274// --- algo.Bool.value.SetEnum
  275// Set value of field from enum type.
  276inline void algo::value_SetEnum(algo::Bool& parent, algo_BoolEnum rhs) {
  277    parent.value = u8(rhs);
  278}
  279
  280// --- algo.Bool.value.Cast
  281inline algo::Bool::operator algo_BoolEnum () const {
  282    return algo_BoolEnum((*this).value);
  283}
  284
  285// --- algo.Bool..Init
  286// Set all fields to initial values.
  287inline void algo::Bool_Init(algo::Bool& parent) {
  288    parent.value = u8(false);
  289}
  290inline algo::ByteAry::ByteAry() {
  291    algo::ByteAry_Init(*this);
  292}
  293
  294inline algo::ByteAry::~ByteAry() {
  295    algo::ByteAry_Uninit(*this);
  296}
  297
  298
  299// --- algo.ByteAry.ary.EmptyQ
  300// Return true if index is empty
  301inline bool algo::ary_EmptyQ(algo::ByteAry& parent) {
  302    return parent.ary_n == 0;
  303}
  304
  305// --- algo.ByteAry.ary.Find
  306// Look up row by row id. Return NULL if out of range
  307inline u8* algo::ary_Find(algo::ByteAry& parent, u64 t) {
  308    u64 idx = t;
  309    u64 lim = parent.ary_n;
  310    if (idx >= lim) return NULL;
  311    return parent.ary_elems + idx;
  312}
  313
  314// --- algo.ByteAry.ary.Getary
  315// Return array pointer by value
  316inline algo::aryptr<u8> algo::ary_Getary(const algo::ByteAry& parent) {
  317    return algo::aryptr<u8>(parent.ary_elems, parent.ary_n);
  318}
  319
  320// --- algo.ByteAry.ary.Last
  321// Return pointer to last element of array, or NULL if array is empty
  322inline u8* algo::ary_Last(algo::ByteAry& parent) {
  323    return ary_Find(parent, u64(parent.ary_n-1));
  324}
  325
  326// --- algo.ByteAry.ary.Max
  327// Return max. number of items in the array
  328inline i32 algo::ary_Max(algo::ByteAry& parent) {
  329    (void)parent;
  330    return parent.ary_max;
  331}
  332
  333// --- algo.ByteAry.ary.N
  334// Return number of items in the array
  335inline i32 algo::ary_N(const algo::ByteAry& parent) {
  336    return parent.ary_n;
  337}
  338
  339// --- algo.ByteAry.ary.RemoveAll
  340inline void algo::ary_RemoveAll(algo::ByteAry& parent) {
  341    parent.ary_n = 0;
  342}
  343
  344// --- algo.ByteAry.ary.Reserve
  345// Make sure N *more* elements will fit in array. Process dies if out of memory
  346inline void algo::ary_Reserve(algo::ByteAry& parent, int n) {
  347    u32 new_n = parent.ary_n + n;
  348    if (UNLIKELY(new_n > parent.ary_max)) {
  349        ary_AbsReserve(parent, new_n);
  350    }
  351}
  352
  353// --- algo.ByteAry.ary.qFind
  354// 'quick' Access row by row id. No bounds checking.
  355inline u8& algo::ary_qFind(algo::ByteAry& parent, u64 t) {
  356    return parent.ary_elems[t];
  357}
  358
  359// --- algo.ByteAry.ary.qLast
  360// Return reference to last element of array. No bounds checking
  361inline u8& algo::ary_qLast(algo::ByteAry& parent) {
  362    return ary_qFind(parent, u64(parent.ary_n-1));
  363}
  364
  365// --- algo.ByteAry.ary.rowid_Get
  366// Return row id of specified element
  367inline u64 algo::ary_rowid_Get(algo::ByteAry& parent, u8 &elem) {
  368    u64 id = &elem - parent.ary_elems;
  369    return u64(id);
  370}
  371
  372// --- algo.ByteAry.ary.Cast
  373inline algo::ByteAry::operator algo::memptr () const {
  374    return ary_Getary(*this);
  375}
  376
  377// --- algo.ByteAry.ary_curs.Next
  378// proceed to next item
  379inline void algo::ByteAry_ary_curs_Next(ByteAry_ary_curs &curs) {
  380    curs.index++;
  381}
  382
  383// --- algo.ByteAry.ary_curs.Reset
  384inline void algo::ByteAry_ary_curs_Reset(ByteAry_ary_curs &curs, algo::ByteAry &parent) {
  385    curs.elems = parent.ary_elems;
  386    curs.n_elems = parent.ary_n;
  387    curs.index = 0;
  388}
  389
  390// --- algo.ByteAry.ary_curs.ValidQ
  391// cursor points to valid item
  392inline bool algo::ByteAry_ary_curs_ValidQ(ByteAry_ary_curs &curs) {
  393    return curs.index < curs.n_elems;
  394}
  395
  396// --- algo.ByteAry.ary_curs.Access
  397// item access
  398inline u8& algo::ByteAry_ary_curs_Access(ByteAry_ary_curs &curs) {
  399    return curs.elems[curs.index];
  400}
  401
  402// --- algo.ByteAry..Init
  403// Set all fields to initial values.
  404inline void algo::ByteAry_Init(algo::ByteAry& parent) {
  405    parent.ary_elems 	= 0; // (algo.ByteAry.ary)
  406    parent.ary_n     	= 0; // (algo.ByteAry.ary)
  407    parent.ary_max   	= 0; // (algo.ByteAry.ary)
  408}
  409inline algo::Charset::Charset() {
  410    algo::Charset_Init(*this);
  411}
  412
  413
  414// --- algo.Charset.ch.NBits
  415// Get max # of bits in the bitset
  416// Return max. number of bits supported by array
  417inline int algo::ch_Nbits(algo::Charset& parent) {
  418    return ch_N(parent) * 64;
  419}
  420
  421// --- algo.Charset.ch.qGetBit
  422// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
  423inline bool algo::ch_qGetBit(algo::Charset& parent, u32 bit_idx) {
  424    u64 elem_idx = bit_idx >> 6;
  425    u64 shift = bit_idx & 63;
  426    u64 &elem = ch_qFind(parent, elem_idx); // fetch element
  427    return bool((elem >> shift) & 1); // extract bit
  428}
  429
  430// --- algo.Charset.ch.GetBit
  431// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
  432inline bool algo::ch_GetBit(algo::Charset& parent, u32 bit_idx) {
  433    u64 elem_idx = bit_idx >> 6;
  434    u64 shift = bit_idx & 63;
  435    bool ret = false;
  436    u64 lim = ch_N(parent);
  437    if (elem_idx < lim) {
  438        u64 &elem = ch_qFind(parent, elem_idx); // fetch element
  439        ret = (elem >> shift) & 1;                 // extract bit
  440    }
  441    return ret;
  442}
  443
  444// --- algo.Charset.ch.BitsEmptyQ
  445// Check if all the bits in the bitset are equal to zero
  446inline bool algo::ch_BitsEmptyQ(algo::Charset& parent) {
  447    bool retval = true;
  448    u64 n = ch_N(parent);
  449    for (u64 i = 0; i < n; i++) {
  450        if (ch_qFind(parent,i) != 0) {
  451            retval = false;
  452            break;
  453        }
  454    }
  455    return retval;
  456}
  457
  458// --- algo.Charset.ch.Sum1s
  459inline u64 algo::ch_Sum1s(algo::Charset& parent) {
  460    u64 sum = 0;
  461    u64 n = ch_N(parent);
  462    for (u64 i = 0; i < n; i++) {
  463        sum += algo::u64_Count1s(ch_qFind(parent, i));
  464    }
  465    return sum;
  466}
  467
  468// --- algo.Charset.ch.qClearBit
  469// Clear bit # BIT_IDX in bit set. No bounds checking
  470inline void algo::ch_qClearBit(algo::Charset& parent, u32 bit_idx) {
  471    u64 elem_idx = bit_idx >> 6;
  472    u64 shift = bit_idx & 63;
  473    u64 &elem = ch_qFind(parent, elem_idx); // fetch
  474    elem = elem & ~(u64(1) << shift); // clear bit
  475}
  476
  477// --- algo.Charset.ch.ClearBit
  478// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
  479inline void algo::ch_ClearBit(algo::Charset& parent, u32 bit_idx) {
  480    u64 elem_idx = bit_idx >> 6;
  481    u64 shift = bit_idx & 63;
  482    u64 lim = ch_N(parent);
  483    if (elem_idx < lim) {
  484        u64 &elem = ch_qFind(parent, elem_idx); // fetch
  485        elem = elem & ~(u64(1) << shift); // clear bit
  486    }
  487}
  488
  489// --- algo.Charset.ch.qSetBit
  490// Set bit # BIT_IDX in bit set. No bounds checking
  491inline void algo::ch_qSetBit(algo::Charset& parent, u32 bit_idx) {
  492    u64 elem_idx = bit_idx >> 6;
  493    u64 shift = bit_idx & 63;
  494    u64 &elem = ch_qFind(parent, elem_idx); // fetch
  495    elem = elem | (u64(1) << shift); // set bit
  496}
  497
  498// --- algo.Charset.ch.SetBit
  499// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
  500inline void algo::ch_SetBit(algo::Charset& parent, u32 bit_idx) {
  501    u64 elem_idx = bit_idx >> 6;
  502    u64 shift = bit_idx & 63;
  503    u64 lim = ch_N(parent);
  504    if (elem_idx < lim) {
  505        u64 &elem = ch_qFind(parent, elem_idx); // fetch
  506        elem = elem | (u64(1) << shift); // set bit
  507    }
  508}
  509
  510// --- algo.Charset.ch.qSetBitVal
  511// Set bit # BIT_IDX in bit set. No bounds checking
  512inline void algo::ch_qSetBitVal(algo::Charset& parent, u32 bit_idx, bool val) {
  513    u64 elem_idx = bit_idx >> 6;
  514    u64 shift = bit_idx & 63;
  515    u64 &elem = ch_qFind(parent, elem_idx); // fetch
  516    elem = (elem & ~(u64(1) << shift)) | (u64(val) << shift); // insert new value
  517}
  518
  519// --- algo.Charset.ch.qOrBitVal
  520// Or bit # BIT_IDX in bit set. No bounds checking
  521inline void algo::ch_qOrBitVal(algo::Charset& parent, u32 bit_idx, bool val) {
  522    u64 elem_idx = bit_idx >> 6;
  523    u64 shift = bit_idx & 63;
  524    u64 &elem = ch_qFind(parent, elem_idx); // fetch
  525    elem = elem | (u64(val) << shift); // Or in val into elem
  526}
  527
  528// --- algo.Charset.ch.ClearBitsAll
  529// Set all bits of array to zero.
  530// Note: this does not change what NBits will return.
  531inline void algo::ch_ClearBitsAll(algo::Charset& parent) {
  532    u64 n = ch_N(parent);
  533    for (u64 i = 0; i < n; i++) {
  534        ch_qFind(parent, i) = 0;
  535    }
  536}
  537
  538// --- algo.Charset.ch.ClearBits
  539// Zero in PARENT any bits that are set in RHS.
  540inline void algo::ch_ClearBits(algo::Charset& parent, algo::Charset &rhs) {
  541    u64 n = u64_Min(ch_N(parent), ch_N(rhs));
  542    for (u64 i = 0; i < n; i++) {
  543        ch_qFind(parent, i) &= ~ch_qFind(rhs, i);
  544    }
  545}
  546
  547// --- algo.Charset.ch.OrBits
  548// Set PARENT to union of two bitsets.
  549// (This function is not named Set.. to avoid triple entendre).
  550inline void algo::ch_OrBits(algo::Charset& parent, algo::Charset &rhs) {
  551    u64 n = u64_Min(ch_N(parent), ch_N(rhs));
  552    for (u64 i = 0; i < n; i++) {
  553        ch_qFind(parent, i) |= ch_qFind(rhs, i);
  554    }
  555}
  556
  557// --- algo.Charset.ch.Sup
  558// Return smallest number N such that indexes of all 1 bits are below N
  559inline i32 algo::ch_Sup(algo::Charset& parent) {
  560    u64 lim = ch_N(parent);
  561    i32 ret = 0;
  562    for (int i = lim-1; i >= 0; i--) {
  563        u64 &val = ch_qFind(parent, i);
  564        if (val) {
  565            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
  566            ret = i * 64 + bitidx;
  567            break;
  568        }
  569    }
  570    return ret;
  571}
  572
  573// --- algo.Charset.ch.Fill
  574// Set all elements of fixed array to value RHS
  575inline void algo::ch_Fill(algo::Charset& parent, const u64 &rhs) {
  576    for (int i = 0; i < 8; i++) {
  577        parent.ch_elems[i] = rhs;
  578    }
  579}
  580
  581// --- algo.Charset.ch.Find
  582// Look up row by row id. Return NULL if out of range
  583inline u64* algo::ch_Find(algo::Charset& parent, u64 t) {
  584    u64 idx = t;
  585    u64 lim = 8;
  586    return idx < lim ? parent.ch_elems + idx : NULL; // unsigned comparison with limit
  587}
  588
  589// --- algo.Charset.ch.Getary
  590// Access fixed array ch as aryptr.
  591inline algo::aryptr<u64> algo::ch_Getary(algo::Charset& parent) {
  592    return algo::aryptr<u64>(parent.ch_elems, 8);
  593}
  594
  595// --- algo.Charset.ch.Max
  596// Return max number of items in the array
  597inline i32 algo::ch_Max(algo::Charset& parent) {
  598    (void)parent;
  599    return 8;
  600}
  601
  602// --- algo.Charset.ch.N
  603// Return number of items in the array
  604inline i32 algo::ch_N(const algo::Charset& parent) {
  605    (void)parent;//only to avoid -Wunused-parameter
  606    return 8;
  607}
  608
  609// --- algo.Charset.ch.Setary
  610// Set contents of fixed array to RHS; Input length is trimmed as necessary
  611inline void algo::ch_Setary(algo::Charset& parent, const algo::aryptr<u64> &rhs) {
  612    int n = 8 < rhs.n_elems ? 8 : rhs.n_elems;
  613    for (int i = 0; i < n; i++) {
  614        parent.ch_elems[i] = rhs[i];
  615    }
  616}
  617
  618// --- algo.Charset.ch.qFind
  619// 'quick' Access row by row id. No bounds checking in release.
  620inline u64& algo::ch_qFind(algo::Charset& parent, u64 t) {
  621    return parent.ch_elems[u64(t)];
  622}
  623
  624// --- algo.Charset.ch_bitcurs.Reset
  625inline void algo::Charset_ch_bitcurs_Reset(Charset_ch_bitcurs &curs, algo::Charset &parent) {
  626    curs.elems = &ch_qFind(parent,0);
  627    curs.n_elems = ch_N(parent);
  628    curs.bit = -1;
  629    Charset_ch_bitcurs_Next(curs);
  630}
  631
  632// --- algo.Charset.ch_bitcurs.ValidQ
  633// cursor points to valid item
  634inline bool algo::Charset_ch_bitcurs_ValidQ(Charset_ch_bitcurs &curs) {
  635    return curs.bit < curs.n_elems*64;
  636}
  637
  638// --- algo.Charset.ch_bitcurs.Access
  639// item access
  640inline int& algo::Charset_ch_bitcurs_Access(Charset_ch_bitcurs &curs) {
  641    return curs.bit;
  642}
  643
  644// --- algo.Charset.ch_curs.Reset
  645// cursor points to valid item
  646inline void algo::Charset_ch_curs_Reset(Charset_ch_curs &curs, algo::Charset &parent) {
  647    curs.parent = &parent;
  648    curs.index = 0;
  649}
  650
  651// --- algo.Charset.ch_curs.ValidQ
  652// cursor points to valid item
  653inline bool algo::Charset_ch_curs_ValidQ(Charset_ch_curs &curs) {
  654    return u64(curs.index) < u64(8);
  655}
  656
  657// --- algo.Charset.ch_curs.Next
  658// proceed to next item
  659inline void algo::Charset_ch_curs_Next(Charset_ch_curs &curs) {
  660    curs.index++;
  661}
  662
  663// --- algo.Charset.ch_curs.Access
  664// item access
  665inline u64& algo::Charset_ch_curs_Access(Charset_ch_curs &curs) {
  666    return ch_qFind((*curs.parent), u64(curs.index));
  667}
  668
  669// --- algo.Charset..Init
  670// Set all fields to initial values.
  671inline void algo::Charset_Init(algo::Charset& parent) {
  672    for (int i = 0; i < 8; i++) {
  673        parent.ch_elems[i] = 0;
  674    }
  675}
  676
  677inline bool algo::Smallstr150::operator ==(const algo::Smallstr150 &rhs) const {
  678    return algo::Smallstr150_Eq(const_cast<algo::Smallstr150&>(*this),const_cast<algo::Smallstr150&>(rhs));
  679}
  680
  681inline bool algo::Smallstr150::operator !=(const algo::Smallstr150 &rhs) const {
  682    return !algo::Smallstr150_Eq(const_cast<algo::Smallstr150&>(*this),const_cast<algo::Smallstr150&>(rhs));
  683}
  684
  685inline bool algo::Smallstr150::operator ==(const algo::strptr &rhs) const {
  686    return algo::Smallstr150_EqStrptr(const_cast<algo::Smallstr150&>(*this),rhs);
  687}
  688inline algo::Smallstr150::Smallstr150() {
  689    algo::Smallstr150_Init(*this);
  690}
  691
  692
  693// --- algo.Smallstr150.ch.Add
  694// Append character to string.
  695// If there is no space for an extra character, do nothing.
  696inline void algo::ch_Add(algo::Smallstr150& parent, char c) {
  697    if (parent.n_ch < 150) {
  698        parent.ch[parent.n_ch++] = c;
  699    }
  700}
  701
  702// --- algo.Smallstr150.ch.AddStrptr
  703// Append string to this string.
  704// If there is no space for an extra character, trim.
  705// If there is no space left, dump core in debug mode.
  706inline void algo::ch_AddStrptr(algo::Smallstr150& parent, algo::strptr str) {
  707    int n_new = str.n_elems;
  708    if (parent.n_ch + n_new > 150) {
  709        n_new = 150 - parent.n_ch;
  710    }
  711    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
  712    parent.n_ch = u8(parent.n_ch + n_new);
  713}
  714
  715// --- algo.Smallstr150.ch.Getary
  716// Access string as array of chars
  717inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr150& parent) {
  718    int len = ch_N(parent);
  719    algo::aryptr<char> ret((char*)parent.ch, len);
  720    return ret;
  721}
  722
  723// --- algo.Smallstr150.ch.HashStrptr
  724inline u32 algo::Smallstr150_Hash(u32 prev, const algo::strptr &str) {
  725    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
  726}
  727
  728// --- algo.Smallstr150.ch.Init
  729inline void algo::ch_Init(algo::Smallstr150 &parent) {
  730    parent.n_ch = 0;
  731}
  732
  733// --- algo.Smallstr150.ch.Max
  734// always return constant 150
  735inline int algo::ch_Max(algo::Smallstr150& parent) {
  736    (void)parent;
  737    return 150;
  738}
  739
  740// --- algo.Smallstr150.ch.N
  741inline int algo::ch_N(const algo::Smallstr150& parent) {
  742    u64 ret;
  743    ret = parent.n_ch;
  744    return int(ret);
  745}
  746
  747// --- algo.Smallstr150.ch.AssignStrptr
  748// Copy from strptr (operator=)
  749inline void algo::Smallstr150::operator =(const algo::strptr &str) {
  750    ch_SetStrptr(*this, str);
  751}
  752
  753// --- algo.Smallstr150.ch.Set
  754// Copy from same type
  755// Copy value from RHS.
  756inline void algo::Smallstr150::operator =(const algo::Smallstr150& parent) {
  757    memcpy(ch, parent.ch, parent.n_ch);
  758    n_ch = parent.n_ch;
  759}
  760
  761// --- algo.Smallstr150.ch.Ctor
  762inline  algo::Smallstr150::Smallstr150(const algo::Smallstr150 &rhs) {
  763    operator =(rhs);
  764}
  765
  766// --- algo.Smallstr150.ch.CtorStrptr
  767inline  algo::Smallstr150::Smallstr150(const algo::strptr &rhs) {
  768    ch_SetStrptr(*this, rhs);
  769}
  770
  771// --- algo.Smallstr150.ch.Cast
  772inline algo::Smallstr150::operator algo::strptr () const {
  773    return ch_Getary(*this);
  774}
  775
  776// --- algo.Smallstr150..Cmp
  777inline i32 algo::Smallstr150_Cmp(algo::Smallstr150& lhs, algo::Smallstr150& rhs) {
  778    i32 retval = 0;
  779    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
  780    return retval;
  781}
  782
  783// --- algo.Smallstr150..Init
  784// Set all fields to initial values.
  785inline void algo::Smallstr150_Init(algo::Smallstr150& parent) {
  786    parent.n_ch = 0;
  787}
  788
  789// --- algo.Smallstr150..Eq
  790inline bool algo::Smallstr150_Eq(algo::Smallstr150& lhs, algo::Smallstr150& rhs) {
  791    bool retval = true;
  792    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
  793    return retval;
  794}
  795
  796// --- algo.Smallstr150..EqStrptr
  797inline bool algo::Smallstr150_EqStrptr(const algo::Smallstr150& lhs, const algo::strptr& rhs) {
  798    return algo::strptr_Eq(ch_Getary(lhs), rhs);
  799}
  800inline algo::Comment::Comment(const algo::strptr&            in_value)
  801    : value(in_value)
  802{
  803}
  804inline algo::Comment::Comment() {
  805}
  806
  807
  808// --- algo.Comment.value.Cast
  809inline algo::Comment::operator algo::strptr () const {
  810    return algo::strptr((*this).value);
  811}
  812
  813// --- algo.Comment..Cmp
  814inline i32 algo::Comment_Cmp(algo::Comment& lhs, algo::Comment& rhs) {
  815    i32 retval = 0;
  816    retval = algo::Smallstr150_Cmp(lhs.value, rhs.value);
  817    return retval;
  818}
  819
  820// --- algo.Comment..Eq
  821inline bool algo::Comment_Eq(algo::Comment& lhs, algo::Comment& rhs) {
  822    bool retval = true;
  823    retval = algo::Smallstr150_Eq(lhs.value, rhs.value);
  824    return retval;
  825}
  826
  827inline bool algo::Smallstr250::operator ==(const algo::Smallstr250 &rhs) const {
  828    return algo::Smallstr250_Eq(const_cast<algo::Smallstr250&>(*this),const_cast<algo::Smallstr250&>(rhs));
  829}
  830
  831inline bool algo::Smallstr250::operator !=(const algo::Smallstr250 &rhs) const {
  832    return !algo::Smallstr250_Eq(const_cast<algo::Smallstr250&>(*this),const_cast<algo::Smallstr250&>(rhs));
  833}
  834
  835inline bool algo::Smallstr250::operator ==(const algo::strptr &rhs) const {
  836    return algo::Smallstr250_EqStrptr(const_cast<algo::Smallstr250&>(*this),rhs);
  837}
  838inline algo::Smallstr250::Smallstr250() {
  839    algo::Smallstr250_Init(*this);
  840}
  841
  842
  843// --- algo.Smallstr250.ch.Add
  844// Append character to string.
  845// If there is no space for an extra character, do nothing.
  846inline void algo::ch_Add(algo::Smallstr250& parent, char c) {
  847    if (parent.n_ch < 250) {
  848        parent.ch[parent.n_ch++] = c;
  849    }
  850}
  851
  852// --- algo.Smallstr250.ch.AddStrptr
  853// Append string to this string.
  854// If there is no space for an extra character, trim.
  855// If there is no space left, dump core in debug mode.
  856inline void algo::ch_AddStrptr(algo::Smallstr250& parent, algo::strptr str) {
  857    int n_new = str.n_elems;
  858    if (parent.n_ch + n_new > 250) {
  859        n_new = 250 - parent.n_ch;
  860    }
  861    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
  862    parent.n_ch = u8(parent.n_ch + n_new);
  863}
  864
  865// --- algo.Smallstr250.ch.Getary
  866// Access string as array of chars
  867inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr250& parent) {
  868    int len = ch_N(parent);
  869    algo::aryptr<char> ret((char*)parent.ch, len);
  870    return ret;
  871}
  872
  873// --- algo.Smallstr250.ch.HashStrptr
  874inline u32 algo::Smallstr250_Hash(u32 prev, const algo::strptr &str) {
  875    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
  876}
  877
  878// --- algo.Smallstr250.ch.Init
  879inline void algo::ch_Init(algo::Smallstr250 &parent) {
  880    parent.n_ch = 0;
  881}
  882
  883// --- algo.Smallstr250.ch.Max
  884// always return constant 250
  885inline int algo::ch_Max(algo::Smallstr250& parent) {
  886    (void)parent;
  887    return 250;
  888}
  889
  890// --- algo.Smallstr250.ch.N
  891inline int algo::ch_N(const algo::Smallstr250& parent) {
  892    u64 ret;
  893    ret = parent.n_ch;
  894    return int(ret);
  895}
  896
  897// --- algo.Smallstr250.ch.AssignStrptr
  898// Copy from strptr (operator=)
  899inline void algo::Smallstr250::operator =(const algo::strptr &str) {
  900    ch_SetStrptr(*this, str);
  901}
  902
  903// --- algo.Smallstr250.ch.Set
  904// Copy from same type
  905// Copy value from RHS.
  906inline void algo::Smallstr250::operator =(const algo::Smallstr250& parent) {
  907    memcpy(ch, parent.ch, parent.n_ch);
  908    n_ch = parent.n_ch;
  909}
  910
  911// --- algo.Smallstr250.ch.Ctor
  912inline  algo::Smallstr250::Smallstr250(const algo::Smallstr250 &rhs) {
  913    operator =(rhs);
  914}
  915
  916// --- algo.Smallstr250.ch.CtorStrptr
  917inline  algo::Smallstr250::Smallstr250(const algo::strptr &rhs) {
  918    ch_SetStrptr(*this, rhs);
  919}
  920
  921// --- algo.Smallstr250.ch.Cast
  922inline algo::Smallstr250::operator algo::strptr () const {
  923    return ch_Getary(*this);
  924}
  925
  926// --- algo.Smallstr250..Cmp
  927inline i32 algo::Smallstr250_Cmp(algo::Smallstr250& lhs, algo::Smallstr250& rhs) {
  928    i32 retval = 0;
  929    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
  930    return retval;
  931}
  932
  933// --- algo.Smallstr250..Init
  934// Set all fields to initial values.
  935inline void algo::Smallstr250_Init(algo::Smallstr250& parent) {
  936    parent.n_ch = 0;
  937}
  938
  939// --- algo.Smallstr250..Eq
  940inline bool algo::Smallstr250_Eq(algo::Smallstr250& lhs, algo::Smallstr250& rhs) {
  941    bool retval = true;
  942    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
  943    return retval;
  944}
  945
  946// --- algo.Smallstr250..EqStrptr
  947inline bool algo::Smallstr250_EqStrptr(const algo::Smallstr250& lhs, const algo::strptr& rhs) {
  948    return algo::strptr_Eq(ch_Getary(lhs), rhs);
  949}
  950inline algo::CppExpr::CppExpr(const algo::strptr&            in_value)
  951    : value(in_value)
  952{
  953}
  954inline algo::CppExpr::CppExpr() {
  955}
  956
  957inline algo::UnTime::UnTime(i64                            in_value)
  958    : value(in_value)
  959{
  960}
  961
  962inline bool algo::UnTime::operator ==(const algo::UnTime &rhs) const {
  963    return algo::UnTime_Eq(const_cast<algo::UnTime&>(*this),const_cast<algo::UnTime&>(rhs));
  964}
  965
  966inline bool algo::UnTime::operator !=(const algo::UnTime &rhs) const {
  967    return !algo::UnTime_Eq(const_cast<algo::UnTime&>(*this),const_cast<algo::UnTime&>(rhs));
  968}
  969
  970inline bool algo::UnTime::operator <(const algo::UnTime &rhs) const {
  971    return algo::UnTime_Lt(const_cast<algo::UnTime&>(*this),const_cast<algo::UnTime&>(rhs));
  972}
  973
  974inline bool algo::UnTime::operator >(const algo::UnTime &rhs) const {
  975    return rhs < *this;
  976}
  977
  978inline bool algo::UnTime::operator <=(const algo::UnTime &rhs) const {
  979    return !(rhs < *this);
  980}
  981
  982inline bool algo::UnTime::operator >=(const algo::UnTime &rhs) const {
  983    return !(*this < rhs);
  984}
  985inline algo::UnTime::UnTime() {
  986    algo::UnTime_Init(*this);
  987}
  988
  989
  990// --- algo.UnTime..Hash
  991inline u32 algo::UnTime_Hash(u32 prev, algo::UnTime rhs) {
  992    prev = i64_Hash(prev, rhs.value);
  993    return prev;
  994}
  995
  996// --- algo.UnTime..Lt
  997inline bool algo::UnTime_Lt(algo::UnTime lhs, algo::UnTime rhs) {
  998    return i64_Lt(lhs.value, rhs.value);
  999}
 1000
 1001// --- algo.UnTime..Cmp
 1002inline i32 algo::UnTime_Cmp(algo::UnTime lhs, algo::UnTime rhs) {
 1003    i32 retval = 0;
 1004    retval = i64_Cmp(lhs.value, rhs.value);
 1005    return retval;
 1006}
 1007
 1008// --- algo.UnTime..Init
 1009// Set all fields to initial values.
 1010inline void algo::UnTime_Init(algo::UnTime& parent) {
 1011    parent.value = i64(0);
 1012}
 1013
 1014// --- algo.UnTime..UpdateMax
 1015// Attempt to make LHS bigger. Return true if it was changed
 1016inline bool algo::UnTime_UpdateMax(algo::UnTime &lhs, algo::UnTime rhs) {
 1017    bool retval = lhs < rhs;
 1018    if (retval) {
 1019        lhs = rhs;
 1020    }
 1021    return retval;
 1022}
 1023
 1024// --- algo.UnTime..Min
 1025// Return the lesser of two values
 1026inline algo::UnTime algo::UnTime_Min(algo::UnTime lhs, algo::UnTime rhs) {
 1027    return lhs < rhs ? lhs : rhs;
 1028}
 1029
 1030// --- algo.UnTime..UpdateMin
 1031// Attempt to make LHS smaller. Return true if it was changed
 1032inline bool algo::UnTime_UpdateMin(algo::UnTime &lhs, algo::UnTime rhs) {
 1033    bool retval = rhs < lhs;
 1034    if (retval) {
 1035        lhs = rhs;
 1036    }
 1037    return retval;
 1038}
 1039
 1040// --- algo.UnTime..Max
 1041// Return the greater of two values
 1042inline algo::UnTime algo::UnTime_Max(algo::UnTime lhs, algo::UnTime rhs) {
 1043    return rhs < lhs ? lhs : rhs;
 1044}
 1045
 1046// --- algo.UnTime..Eq
 1047inline bool algo::UnTime_Eq(algo::UnTime lhs, algo::UnTime rhs) {
 1048    bool retval = true;
 1049    retval = i64_Eq(lhs.value, rhs.value);
 1050    return retval;
 1051}
 1052
 1053// --- algo.UnTime..Update
 1054// Set value. Return true if new value is different from old value.
 1055inline bool algo::UnTime_Update(algo::UnTime &lhs, algo::UnTime rhs) {
 1056    bool ret = !UnTime_Eq(lhs, rhs); // compare values
 1057    if (ret) {
 1058        lhs = rhs; // update
 1059    }
 1060    return ret;
 1061}
 1062inline algo::DateCache::DateCache() {
 1063}
 1064
 1065inline algo::DayRange::DayRange(algo::UnTime                   in_start
 1066        ,algo::UnTime                   in_end)
 1067    : start(in_start)
 1068    , end(in_end)
 1069{
 1070}
 1071inline algo::DayRange::DayRange() {
 1072}
 1073
 1074inline algo::Decimal::Decimal(i32                            in_exponent
 1075        ,i64                            in_mantissa)
 1076    : exponent(in_exponent)
 1077    , mantissa(in_mantissa)
 1078{
 1079}
 1080
 1081inline bool algo::Decimal::operator ==(const algo::Decimal &rhs) const {
 1082    return algo::Decimal_Eq(const_cast<algo::Decimal&>(*this),const_cast<algo::Decimal&>(rhs));
 1083}
 1084
 1085inline bool algo::Decimal::operator !=(const algo::Decimal &rhs) const {
 1086    return !algo::Decimal_Eq(const_cast<algo::Decimal&>(*this),const_cast<algo::Decimal&>(rhs));
 1087}
 1088inline algo::Decimal::Decimal() {
 1089    algo::Decimal_Init(*this);
 1090}
 1091
 1092
 1093// --- algo.Decimal..Cmp
 1094inline i32 algo::Decimal_Cmp(algo::Decimal lhs, algo::Decimal rhs) {
 1095    i32 retval = 0;
 1096    retval = i32_Cmp(lhs.exponent, rhs.exponent);
 1097    if (retval != 0) {
 1098        return retval;
 1099    }
 1100    retval = i64_Cmp(lhs.mantissa, rhs.mantissa);
 1101    return retval;
 1102}
 1103
 1104// --- algo.Decimal..Init
 1105// Set all fields to initial values.
 1106inline void algo::Decimal_Init(algo::Decimal& parent) {
 1107    parent.exponent = i32(0);
 1108    parent.mantissa = i64(0);
 1109}
 1110
 1111// --- algo.Decimal..Eq
 1112inline bool algo::Decimal_Eq(algo::Decimal lhs, algo::Decimal rhs) {
 1113    bool retval = true;
 1114    retval = i32_Eq(lhs.exponent, rhs.exponent);
 1115    if (!retval) {
 1116        return false;
 1117    }
 1118    retval = i64_Eq(lhs.mantissa, rhs.mantissa);
 1119    return retval;
 1120}
 1121inline algo::DirEntry::DirEntry() {
 1122    algo::DirEntry_Init(*this);
 1123}
 1124
 1125inline algo::DirEntry::~DirEntry() {
 1126    algo::DirEntry_Uninit(*this);
 1127}
 1128
 1129inline algo::DryrunQ::DryrunQ(bool                           in_value)
 1130    : value(in_value)
 1131{
 1132}
 1133inline algo::DryrunQ::DryrunQ() {
 1134    algo::DryrunQ_Init(*this);
 1135}
 1136
 1137
 1138// --- algo.DryrunQ.value.Cast
 1139inline algo::DryrunQ::operator bool () const {
 1140    return bool((*this).value);
 1141}
 1142
 1143// --- algo.DryrunQ..Init
 1144// Set all fields to initial values.
 1145inline void algo::DryrunQ_Init(algo::DryrunQ& parent) {
 1146    parent.value = bool(false);
 1147}
 1148inline algo::EchoQ::EchoQ(bool                           in_value)
 1149    : value(in_value)
 1150{
 1151}
 1152inline algo::EchoQ::EchoQ(algo_EchoQEnum arg) { this->value = bool(arg); }
 1153inline algo::EchoQ::EchoQ() {
 1154    algo::EchoQ_Init(*this);
 1155}
 1156
 1157
 1158// --- algo.EchoQ.value.GetEnum
 1159// Get value of field as enum type
 1160inline algo_EchoQEnum algo::value_GetEnum(const algo::EchoQ& parent) {
 1161    return algo_EchoQEnum(parent.value);
 1162}
 1163
 1164// --- algo.EchoQ.value.SetEnum
 1165// Set value of field from enum type.
 1166inline void algo::value_SetEnum(algo::EchoQ& parent, algo_EchoQEnum rhs) {
 1167    parent.value = bool(rhs);
 1168}
 1169
 1170// --- algo.EchoQ.value.Cast
 1171inline algo::EchoQ::operator algo_EchoQEnum () const {
 1172    return algo_EchoQEnum((*this).value);
 1173}
 1174
 1175// --- algo.EchoQ..Init
 1176// Set all fields to initial values.
 1177inline void algo::EchoQ_Init(algo::EchoQ& parent) {
 1178    parent.value = bool(false);
 1179}
 1180inline algo::Errns::Errns(u8                             in_value)
 1181    : value(in_value)
 1182{
 1183}
 1184inline algo::Errns::Errns(algo_ErrnsEnum arg) { this->value = u8(arg); }
 1185inline algo::Errns::Errns() {
 1186    algo::Errns_Init(*this);
 1187}
 1188
 1189
 1190// --- algo.Errns.value.GetEnum
 1191// Get value of field as enum type
 1192inline algo_ErrnsEnum algo::value_GetEnum(const algo::Errns& parent) {
 1193    return algo_ErrnsEnum(parent.value);
 1194}
 1195
 1196// --- algo.Errns.value.SetEnum
 1197// Set value of field from enum type.
 1198inline void algo::value_SetEnum(algo::Errns& parent, algo_ErrnsEnum rhs) {
 1199    parent.value = u8(rhs);
 1200}
 1201
 1202// --- algo.Errns.value.Cast
 1203inline algo::Errns::operator algo_ErrnsEnum () const {
 1204    return algo_ErrnsEnum((*this).value);
 1205}
 1206
 1207// --- algo.Errns..Init
 1208// Set all fields to initial values.
 1209inline void algo::Errns_Init(algo::Errns& parent) {
 1210    parent.value = u8(0);
 1211}
 1212inline algo::Errcode::Errcode() {
 1213    algo::Errcode_Init(*this);
 1214}
 1215
 1216
 1217// --- algo.Errcode.code.Get
 1218// Retrieve bitfield from value of field value
 1219//    32 bits starting at bit 0.
 1220inline i32 algo::code_Get(const algo::Errcode& parent) {
 1221    return i32((parent.value >> 0) & 0xffffffff);
 1222}
 1223
 1224// --- algo.Errcode.code.Set
 1225// Set bitfield in value of field 'value'
 1226//    32 bits starting at bit 0.
 1227inline void algo::code_Set(algo::Errcode& parent, i32 rhs) {
 1228    u64 t1    = u64(0xffffffff) << 0;
 1229    u64 t2    = (u64(rhs) & 0xffffffff) << 0;
 1230    parent.value = u64((parent.value & ~t1) | t2);
 1231}
 1232
 1233// --- algo.Errcode.type.Get
 1234// Retrieve bitfield from value of field value
 1235//    8 bits starting at bit 32.
 1236inline algo::Errns algo::type_Get(const algo::Errcode& parent) {
 1237    return algo::Errns((parent.value >> 32) & 0xff);
 1238}
 1239
 1240// --- algo.Errcode.type.Set
 1241// Set bitfield in value of field 'value'
 1242//    8 bits starting at bit 32.
 1243inline void algo::type_Set(algo::Errcode& parent, algo::Errns rhs) {
 1244    u64 t1    = u64(0xff) << 32;
 1245    u64 t2    = (u64(rhs.value) & 0xff) << 32;
 1246    parent.value = u64((parent.value & ~t1) | t2);
 1247}
 1248
 1249// --- algo.Errcode..Init
 1250// Set all fields to initial values.
 1251inline void algo::Errcode_Init(algo::Errcode& parent) {
 1252    parent.value = u64(0);
 1253}
 1254inline algo::FailokQ::FailokQ(bool                           in_value)
 1255    : value(in_value)
 1256{
 1257}
 1258inline algo::FailokQ::FailokQ(algo_FailokQEnum arg) { this->value = bool(arg); }
 1259inline algo::FailokQ::FailokQ() {
 1260    algo::FailokQ_Init(*this);
 1261}
 1262
 1263
 1264// --- algo.FailokQ.value.GetEnum
 1265// Get value of field as enum type
 1266inline algo_FailokQEnum algo::value_GetEnum(const algo::FailokQ& parent) {
 1267    return algo_FailokQEnum(parent.value);
 1268}
 1269
 1270// --- algo.FailokQ.value.SetEnum
 1271// Set value of field from enum type.
 1272inline void algo::value_SetEnum(algo::FailokQ& parent, algo_FailokQEnum rhs) {
 1273    parent.value = bool(rhs);
 1274}
 1275
 1276// --- algo.FailokQ.value.Cast
 1277inline algo::FailokQ::operator algo_FailokQEnum () const {
 1278    return algo_FailokQEnum((*this).value);
 1279}
 1280
 1281// --- algo.FailokQ..Init
 1282// Set all fields to initial values.
 1283inline void algo::FailokQ_Init(algo::FailokQ& parent) {
 1284    parent.value = bool(false);
 1285}
 1286inline algo::FieldId::FieldId(i32                            in_value)
 1287    : value(in_value)
 1288{
 1289}
 1290inline algo::FieldId::FieldId(algo_FieldIdEnum arg) { this->value = i32(arg); }
 1291inline algo::FieldId::FieldId() {
 1292    algo::FieldId_Init(*this);
 1293}
 1294
 1295
 1296// --- algo.FieldId.value.GetEnum
 1297// Get value of field as enum type
 1298inline algo_FieldIdEnum algo::value_GetEnum(const algo::FieldId& parent) {
 1299    return algo_FieldIdEnum(parent.value);
 1300}
 1301
 1302// --- algo.FieldId.value.SetEnum
 1303// Set value of field from enum type.
 1304inline void algo::value_SetEnum(algo::FieldId& parent, algo_FieldIdEnum rhs) {
 1305    parent.value = i32(rhs);
 1306}
 1307
 1308// --- algo.FieldId.value.Cast
 1309inline algo::FieldId::operator algo_FieldIdEnum () const {
 1310    return algo_FieldIdEnum((*this).value);
 1311}
 1312
 1313// --- algo.FieldId..Init
 1314// Set all fields to initial values.
 1315inline void algo::FieldId_Init(algo::FieldId& parent) {
 1316    parent.value = i32(-1);
 1317}
 1318inline algo::Fildes::Fildes(i32                            in_value)
 1319    : value(in_value)
 1320{
 1321}
 1322
 1323inline bool algo::Fildes::operator ==(const algo::Fildes &rhs) const {
 1324    return algo::Fildes_Eq(const_cast<algo::Fildes&>(*this),const_cast<algo::Fildes&>(rhs));
 1325}
 1326
 1327inline bool algo::Fildes::operator !=(const algo::Fildes &rhs) const {
 1328    return !algo::Fildes_Eq(const_cast<algo::Fildes&>(*this),const_cast<algo::Fildes&>(rhs));
 1329}
 1330
 1331inline bool algo::Fildes::operator <(const algo::Fildes &rhs) const {
 1332    return algo::Fildes_Lt(const_cast<algo::Fildes&>(*this),const_cast<algo::Fildes&>(rhs));
 1333}
 1334
 1335inline bool algo::Fildes::operator >(const algo::Fildes &rhs) const {
 1336    return rhs < *this;
 1337}
 1338
 1339inline bool algo::Fildes::operator <=(const algo::Fildes &rhs) const {
 1340    return !(rhs < *this);
 1341}
 1342
 1343inline bool algo::Fildes::operator >=(const algo::Fildes &rhs) const {
 1344    return !(*this < rhs);
 1345}
 1346inline algo::Fildes::Fildes() {
 1347    algo::Fildes_Init(*this);
 1348}
 1349
 1350
 1351// --- algo.Fildes..Hash
 1352inline u32 algo::Fildes_Hash(u32 prev, const algo::Fildes & rhs) {
 1353    prev = i32_Hash(prev, rhs.value);
 1354    return prev;
 1355}
 1356
 1357// --- algo.Fildes..Lt
 1358inline bool algo::Fildes_Lt(algo::Fildes& lhs, algo::Fildes& rhs) {
 1359    return i32_Lt(lhs.value, rhs.value);
 1360}
 1361
 1362// --- algo.Fildes..Cmp
 1363inline i32 algo::Fildes_Cmp(algo::Fildes& lhs, algo::Fildes& rhs) {
 1364    i32 retval = 0;
 1365    retval = i32_Cmp(lhs.value, rhs.value);
 1366    return retval;
 1367}
 1368
 1369// --- algo.Fildes..Init
 1370// Set all fields to initial values.
 1371inline void algo::Fildes_Init(algo::Fildes& parent) {
 1372    parent.value = i32(-1);
 1373}
 1374
 1375// --- algo.Fildes..Eq
 1376inline bool algo::Fildes_Eq(algo::Fildes& lhs, algo::Fildes& rhs) {
 1377    bool retval = true;
 1378    retval = i32_Eq(lhs.value, rhs.value);
 1379    return retval;
 1380}
 1381
 1382// --- algo.Fildes..Update
 1383// Set value. Return true if new value is different from old value.
 1384inline bool algo::Fildes_Update(algo::Fildes &lhs, algo::Fildes& rhs) {
 1385    bool ret = !Fildes_Eq(lhs, rhs); // compare values
 1386    if (ret) {
 1387        lhs = rhs; // update
 1388    }
 1389    return ret;
 1390}
 1391inline algo::FileFlags::FileFlags(u32                            in_value)
 1392    : value(in_value)
 1393{
 1394}
 1395inline algo::FileFlags::FileFlags(algo_FileFlagsEnum arg) { this->value = u32(arg); }
 1396inline algo::FileFlags::FileFlags() {
 1397    algo::FileFlags_Init(*this);
 1398}
 1399
 1400
 1401// --- algo.FileFlags.value.Cast
 1402inline algo::FileFlags::operator algo_FileFlagsEnum () const {
 1403    return algo_FileFlagsEnum((*this).value);
 1404}
 1405
 1406// --- algo.FileFlags.append.Get
 1407// Retrieve bitfield from value of field value
 1408//    1 bits starting at bit 4.
 1409inline bool algo::append_Get(const algo::FileFlags& parent) {
 1410    return bool((parent.value >> 4) & 0x01);
 1411}
 1412
 1413// --- algo.FileFlags.append.Set
 1414// Set bitfield in value of field 'value'
 1415//    1 bits starting at bit 4.
 1416inline void algo::append_Set(algo::FileFlags& parent, bool rhs) {
 1417    u32 t1    = u32(0x01) << 4;
 1418    u32 t2    = (u32(rhs) & 0x01) << 4;
 1419    parent.value = u32((parent.value & ~t1) | t2);
 1420}
 1421
 1422// --- algo.FileFlags.read.Get
 1423// Retrieve bitfield from value of field value
 1424//    1 bits starting at bit 0.
 1425inline bool algo::read_Get(const algo::FileFlags& parent) {
 1426    return bool((parent.value >> 0) & 0x01);
 1427}
 1428
 1429// --- algo.FileFlags.read.Set
 1430// Set bitfield in value of field 'value'
 1431//    1 bits starting at bit 0.
 1432inline void algo::read_Set(algo::FileFlags& parent, bool rhs) {
 1433    u32 t1    = u32(0x01) << 0;
 1434    u32 t2    = (u32(rhs) & 0x01) << 0;
 1435    parent.value = u32((parent.value & ~t1) | t2);
 1436}
 1437
 1438// --- algo.FileFlags.write.Get
 1439// Retrieve bitfield from value of field value
 1440//    1 bits starting at bit 1.
 1441inline bool algo::write_Get(const algo::FileFlags& parent) {
 1442    return bool((parent.value >> 1) & 0x01);
 1443}
 1444
 1445// --- algo.FileFlags.write.Set
 1446// Set bitfield in value of field 'value'
 1447//    1 bits starting at bit 1.
 1448inline void algo::write_Set(algo::FileFlags& parent, bool rhs) {
 1449    u32 t1    = u32(0x01) << 1;
 1450    u32 t2    = (u32(rhs) & 0x01) << 1;
 1451    parent.value = u32((parent.value & ~t1) | t2);
 1452}
 1453
 1454// --- algo.FileFlags._throw.Get
 1455// Retrieve bitfield from value of field value
 1456//    1 bits starting at bit 5.
 1457inline bool algo::_throw_Get(const algo::FileFlags& parent) {
 1458    return bool((parent.value >> 5) & 0x01);
 1459}
 1460
 1461// --- algo.FileFlags._throw.Set
 1462// Set bitfield in value of field 'value'
 1463//    1 bits starting at bit 5.
 1464inline void algo::_throw_Set(algo::FileFlags& parent, bool rhs) {
 1465    u32 t1    = u32(0x01) << 5;
 1466    u32 t2    = (u32(rhs) & 0x01) << 5;
 1467    parent.value = u32((parent.value & ~t1) | t2);
 1468}
 1469
 1470// --- algo.FileFlags.temp.Get
 1471// Retrieve bitfield from value of field value
 1472//    1 bits starting at bit 6.
 1473inline bool algo::temp_Get(const algo::FileFlags& parent) {
 1474    return bool((parent.value >> 6) & 0x01);
 1475}
 1476
 1477// --- algo.FileFlags.temp.Set
 1478// Set bitfield in value of field 'value'
 1479//    1 bits starting at bit 6.
 1480inline void algo::temp_Set(algo::FileFlags& parent, bool rhs) {
 1481    u32 t1    = u32(0x01) << 6;
 1482    u32 t2    = (u32(rhs) & 0x01) << 6;
 1483    parent.value = u32((parent.value & ~t1) | t2);
 1484}
 1485
 1486// --- algo.FileFlags.overlap.Get
 1487// Retrieve bitfield from value of field value
 1488//    1 bits starting at bit 7.
 1489inline bool algo::overlap_Get(const algo::FileFlags& parent) {
 1490    return bool((parent.value >> 7) & 0x01);
 1491}
 1492
 1493// --- algo.FileFlags.overlap.Set
 1494// Set bitfield in value of field 'value'
 1495//    1 bits starting at bit 7.
 1496inline void algo::overlap_Set(algo::FileFlags& parent, bool rhs) {
 1497    u32 t1    = u32(0x01) << 7;
 1498    u32 t2    = (u32(rhs) & 0x01) << 7;
 1499    parent.value = u32((parent.value & ~t1) | t2);
 1500}
 1501
 1502// --- algo.FileFlags.linear.Get
 1503// Retrieve bitfield from value of field value
 1504//    1 bits starting at bit 8.
 1505inline bool algo::linear_Get(const algo::FileFlags& parent) {
 1506    return bool((parent.value >> 8) & 0x01);
 1507}
 1508
 1509// --- algo.FileFlags.linear.Set
 1510// Set bitfield in value of field 'value'
 1511//    1 bits starting at bit 8.
 1512inline void algo::linear_Set(algo::FileFlags& parent, bool rhs) {
 1513    u32 t1    = u32(0x01) << 8;
 1514    u32 t2    = (u32(rhs) & 0x01) << 8;
 1515    parent.value = u32((parent.value & ~t1) | t2);
 1516}
 1517
 1518// --- algo.FileFlags.printerr.Get
 1519// Retrieve bitfield from value of field value
 1520//    1 bits starting at bit 9.
 1521inline bool algo::printerr_Get(const algo::FileFlags& parent) {
 1522    return bool((parent.value >> 9) & 0x01);
 1523}
 1524
 1525// --- algo.FileFlags.printerr.Set
 1526// Set bitfield in value of field 'value'
 1527//    1 bits starting at bit 9.
 1528inline void algo::printerr_Set(algo::FileFlags& parent, bool rhs) {
 1529    u32 t1    = u32(0x01) << 9;
 1530    u32 t2    = (u32(rhs) & 0x01) << 9;
 1531    parent.value = u32((parent.value & ~t1) | t2);
 1532}
 1533
 1534// --- algo.FileFlags..Init
 1535// Set all fields to initial values.
 1536inline void algo::FileFlags_Init(algo::FileFlags& parent) {
 1537    parent.value = u32(0);
 1538}
 1539inline algo::I32Dec1::I32Dec1(i32                            in_value)
 1540    : value(in_value)
 1541{
 1542}
 1543inline algo::I32Dec1::I32Dec1() {
 1544    algo::I32Dec1_Init(*this);
 1545}
 1546
 1547
 1548// --- algo.I32Dec1.value.qSetDouble
 1549// Set value of field value.
 1550// The value is rounded to the nearest integer.
 1551// This ensures that truncation of a near-integer value does not occur.
 1552// Example: 1.3 cannot be represented exactly as a double, the actual
 1553// stored value will be 1.29999999. when we apply C truncation,
 1554// we want to end up with 1.3, not 1.2.
 1555inline void algo::value_qSetDouble(algo::I32Dec1& parent, double val) {
 1556    double intval = val * 10 + (val > 0 ? 0.5 : -0.5);
 1557    // set underlying field.
 1558    parent.value = intval;
 1559}
 1560
 1561// --- algo.I32Dec1.value.GetDouble
 1562inline double algo::value_GetDouble(const algo::I32Dec1& parent) {
 1563    double ret;
 1564    ret = parent.value / double(10);
 1565    return ret;
 1566}
 1567
 1568// --- algo.I32Dec1.value.GetInt
 1569// Return integer portion (divide number by 10)
 1570inline i32 algo::value_GetInt(const algo::I32Dec1& parent) {
 1571    i32 ret;
 1572    ret = parent.value / 10;
 1573    return ret;
 1574}
 1575
 1576// --- algo.I32Dec1.value.GetScale
 1577// Return constant 10
 1578inline i32 algo::I32Dec1_GetScale() {
 1579    return 10;
 1580}
 1581
 1582// --- algo.I32Dec1.value.Cast
 1583inline algo::I32Dec1::operator i32 () const {
 1584    return i32((*this).value);
 1585}
 1586
 1587// --- algo.I32Dec1..Hash
 1588inline u32 algo::I32Dec1_Hash(u32 prev, algo::I32Dec1 rhs) {
 1589    prev = i32_Hash(prev, rhs.value);
 1590    return prev;
 1591}
 1592
 1593// --- algo.I32Dec1..Init
 1594// Set all fields to initial values.
 1595inline void algo::I32Dec1_Init(algo::I32Dec1& parent) {
 1596    parent.value = i32(0);
 1597}
 1598inline algo::I32Dec2::I32Dec2(i32                            in_value)
 1599    : value(in_value)
 1600{
 1601}
 1602inline algo::I32Dec2::I32Dec2() {
 1603    algo::I32Dec2_Init(*this);
 1604}
 1605
 1606
 1607// --- algo.I32Dec2.value.qSetDouble
 1608// Set value of field value.
 1609// The value is rounded to the nearest integer.
 1610// This ensures that truncation of a near-integer value does not occur.
 1611// Example: 1.3 cannot be represented exactly as a double, the actual
 1612// stored value will be 1.29999999. when we apply C truncation,
 1613// we want to end up with 1.3, not 1.2.
 1614inline void algo::value_qSetDouble(algo::I32Dec2& parent, double val) {
 1615    double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
 1616    // set underlying field.
 1617    parent.value = intval;
 1618}
 1619
 1620// --- algo.I32Dec2.value.GetDouble
 1621inline double algo::value_GetDouble(const algo::I32Dec2& parent) {
 1622    double ret;
 1623    ret = parent.value / double(100);
 1624    return ret;
 1625}
 1626
 1627// --- algo.I32Dec2.value.GetInt
 1628// Return integer portion (divide number by 100)
 1629inline i32 algo::value_GetInt(const algo::I32Dec2& parent) {
 1630    i32 ret;
 1631    ret = parent.value / 100;
 1632    return ret;
 1633}
 1634
 1635// --- algo.I32Dec2.value.GetScale
 1636// Return constant 100
 1637inline i32 algo::I32Dec2_GetScale() {
 1638    return 100;
 1639}
 1640
 1641// --- algo.I32Dec2.value.Cast
 1642inline algo::I32Dec2::operator i32 () const {
 1643    return i32((*this).value);
 1644}
 1645
 1646// --- algo.I32Dec2..Hash
 1647inline u32 algo::I32Dec2_Hash(u32 prev, algo::I32Dec2 rhs) {
 1648    prev = i32_Hash(prev, rhs.value);
 1649    return prev;
 1650}
 1651
 1652// --- algo.I32Dec2..Init
 1653// Set all fields to initial values.
 1654inline void algo::I32Dec2_Init(algo::I32Dec2& parent) {
 1655    parent.value = i32(0);
 1656}
 1657inline algo::I32Dec3::I32Dec3(i32                            in_value)
 1658    : value(in_value)
 1659{
 1660}
 1661inline algo::I32Dec3::I32Dec3() {
 1662    algo::I32Dec3_Init(*this);
 1663}
 1664
 1665
 1666// --- algo.I32Dec3.value.qSetDouble
 1667// Set value of field value.
 1668// The value is rounded to the nearest integer.
 1669// This ensures that truncation of a near-integer value does not occur.
 1670// Example: 1.3 cannot be represented exactly as a double, the actual
 1671// stored value will be 1.29999999. when we apply C truncation,
 1672// we want to end up with 1.3, not 1.2.
 1673inline void algo::value_qSetDouble(algo::I32Dec3& parent, double val) {
 1674    double intval = val * 1000 + (val > 0 ? 0.5 : -0.5);
 1675    // set underlying field.
 1676    parent.value = intval;
 1677}
 1678
 1679// --- algo.I32Dec3.value.GetDouble
 1680inline double algo::value_GetDouble(const algo::I32Dec3& parent) {
 1681    double ret;
 1682    ret = parent.value / double(1000);
 1683    return ret;
 1684}
 1685
 1686// --- algo.I32Dec3.value.GetInt
 1687// Return integer portion (divide number by 1000)
 1688inline i32 algo::value_GetInt(const algo::I32Dec3& parent) {
 1689    i32 ret;
 1690    ret = parent.value / 1000;
 1691    return ret;
 1692}
 1693
 1694// --- algo.I32Dec3.value.GetScale
 1695// Return constant 1000
 1696inline i32 algo::I32Dec3_GetScale() {
 1697    return 1000;
 1698}
 1699
 1700// --- algo.I32Dec3.value.Cast
 1701inline algo::I32Dec3::operator i32 () const {
 1702    return i32((*this).value);
 1703}
 1704
 1705// --- algo.I32Dec3..Hash
 1706inline u32 algo::I32Dec3_Hash(u32 prev, algo::I32Dec3 rhs) {
 1707    prev = i32_Hash(prev, rhs.value);
 1708    return prev;
 1709}
 1710
 1711// --- algo.I32Dec3..Init
 1712// Set all fields to initial values.
 1713inline void algo::I32Dec3_Init(algo::I32Dec3& parent) {
 1714    parent.value = i32(0);
 1715}
 1716inline algo::I32Dec4::I32Dec4(i32                            in_value)
 1717    : value(in_value)
 1718{
 1719}
 1720inline algo::I32Dec4::I32Dec4() {
 1721    algo::I32Dec4_Init(*this);
 1722}
 1723
 1724
 1725// --- algo.I32Dec4.value.qSetDouble
 1726// Set value of field value.
 1727// The value is rounded to the nearest integer.
 1728// This ensures that truncation of a near-integer value does not occur.
 1729// Example: 1.3 cannot be represented exactly as a double, the actual
 1730// stored value will be 1.29999999. when we apply C truncation,
 1731// we want to end up with 1.3, not 1.2.
 1732inline void algo::value_qSetDouble(algo::I32Dec4& parent, double val) {
 1733    double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
 1734    // set underlying field.
 1735    parent.value = intval;
 1736}
 1737
 1738// --- algo.I32Dec4.value.GetDouble
 1739inline double algo::value_GetDouble(const algo::I32Dec4& parent) {
 1740    double ret;
 1741    ret = parent.value / double(10000);
 1742    return ret;
 1743}
 1744
 1745// --- algo.I32Dec4.value.GetInt
 1746// Return integer portion (divide number by 10000)
 1747inline i32 algo::value_GetInt(const algo::I32Dec4& parent) {
 1748    i32 ret;
 1749    ret = parent.value / 10000;
 1750    return ret;
 1751}
 1752
 1753// --- algo.I32Dec4.value.GetScale
 1754// Return constant 10000
 1755inline i32 algo::I32Dec4_GetScale() {
 1756    return 10000;
 1757}
 1758
 1759// --- algo.I32Dec4.value.Cast
 1760inline algo::I32Dec4::operator i32 () const {
 1761    return i32((*this).value);
 1762}
 1763
 1764// --- algo.I32Dec4..Hash
 1765inline u32 algo::I32Dec4_Hash(u32 prev, algo::I32Dec4 rhs) {
 1766    prev = i32_Hash(prev, rhs.value);
 1767    return prev;
 1768}
 1769
 1770// --- algo.I32Dec4..Init
 1771// Set all fields to initial values.
 1772inline void algo::I32Dec4_Init(algo::I32Dec4& parent) {
 1773    parent.value = i32(0);
 1774}
 1775inline algo::I32Dec5::I32Dec5(i32                            in_value)
 1776    : value(in_value)
 1777{
 1778}
 1779inline algo::I32Dec5::I32Dec5() {
 1780    algo::I32Dec5_Init(*this);
 1781}
 1782
 1783
 1784// --- algo.I32Dec5.value.qSetDouble
 1785// Set value of field value.
 1786// The value is rounded to the nearest integer.
 1787// This ensures that truncation of a near-integer value does not occur.
 1788// Example: 1.3 cannot be represented exactly as a double, the actual
 1789// stored value will be 1.29999999. when we apply C truncation,
 1790// we want to end up with 1.3, not 1.2.
 1791inline void algo::value_qSetDouble(algo::I32Dec5& parent, double val) {
 1792    double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
 1793    // set underlying field.
 1794    parent.value = intval;
 1795}
 1796
 1797// --- algo.I32Dec5.value.GetDouble
 1798inline double algo::value_GetDouble(const algo::I32Dec5& parent) {
 1799    double ret;
 1800    ret = parent.value / double(100000);
 1801    return ret;
 1802}
 1803
 1804// --- algo.I32Dec5.value.GetInt
 1805// Return integer portion (divide number by 100000)
 1806inline i32 algo::value_GetInt(const algo::I32Dec5& parent) {
 1807    i32 ret;
 1808    ret = parent.value / 100000;
 1809    return ret;
 1810}
 1811
 1812// --- algo.I32Dec5.value.GetScale
 1813// Return constant 100000
 1814inline i32 algo::I32Dec5_GetScale() {
 1815    return 100000;
 1816}
 1817
 1818// --- algo.I32Dec5.value.Cast
 1819inline algo::I32Dec5::operator i32 () const {
 1820    return i32((*this).value);
 1821}
 1822
 1823// --- algo.I32Dec5..Hash
 1824inline u32 algo::I32Dec5_Hash(u32 prev, algo::I32Dec5 rhs) {
 1825    prev = i32_Hash(prev, rhs.value);
 1826    return prev;
 1827}
 1828
 1829// --- algo.I32Dec5..Init
 1830// Set all fields to initial values.
 1831inline void algo::I32Dec5_Init(algo::I32Dec5& parent) {
 1832    parent.value = i32(0);
 1833}
 1834inline algo::I64Dec1::I64Dec1(i64                            in_value)
 1835    : value(in_value)
 1836{
 1837}
 1838inline algo::I64Dec1::I64Dec1() {
 1839    algo::I64Dec1_Init(*this);
 1840}
 1841
 1842
 1843// --- algo.I64Dec1.value.qSetDouble
 1844// Set value of field value.
 1845// The value is rounded to the nearest integer.
 1846// This ensures that truncation of a near-integer value does not occur.
 1847// Example: 1.3 cannot be represented exactly as a double, the actual
 1848// stored value will be 1.29999999. when we apply C truncation,
 1849// we want to end up with 1.3, not 1.2.
 1850inline void algo::value_qSetDouble(algo::I64Dec1& parent, double val) {
 1851    double intval = val * 10 + (val > 0 ? 0.5 : -0.5);
 1852    // set underlying field.
 1853    parent.value = intval;
 1854}
 1855
 1856// --- algo.I64Dec1.value.GetDouble
 1857inline double algo::value_GetDouble(const algo::I64Dec1& parent) {
 1858    double ret;
 1859    ret = parent.value / double(10);
 1860    return ret;
 1861}
 1862
 1863// --- algo.I64Dec1.value.GetInt
 1864// Return integer portion (divide number by 10)
 1865inline i64 algo::value_GetInt(const algo::I64Dec1& parent) {
 1866    i64 ret;
 1867    ret = parent.value / 10;
 1868    return ret;
 1869}
 1870
 1871// --- algo.I64Dec1.value.GetScale
 1872// Return constant 10
 1873inline i64 algo::I64Dec1_GetScale() {
 1874    return 10;
 1875}
 1876
 1877// --- algo.I64Dec1.value.Cast
 1878inline algo::I64Dec1::operator i64 () const {
 1879    return i64((*this).value);
 1880}
 1881
 1882// --- algo.I64Dec1..Hash
 1883inline u32 algo::I64Dec1_Hash(u32 prev, algo::I64Dec1 rhs) {
 1884    prev = i64_Hash(prev, rhs.value);
 1885    return prev;
 1886}
 1887
 1888// --- algo.I64Dec1..Init
 1889// Set all fields to initial values.
 1890inline void algo::I64Dec1_Init(algo::I64Dec1& parent) {
 1891    parent.value = i64(0);
 1892}
 1893inline algo::I64Dec10::I64Dec10(i64                            in_value)
 1894    : value(in_value)
 1895{
 1896}
 1897inline algo::I64Dec10::I64Dec10() {
 1898    algo::I64Dec10_Init(*this);
 1899}
 1900
 1901
 1902// --- algo.I64Dec10.value.qSetDouble
 1903// Set value of field value.
 1904// The value is rounded to the nearest integer.
 1905// This ensures that truncation of a near-integer value does not occur.
 1906// Example: 1.3 cannot be represented exactly as a double, the actual
 1907// stored value will be 1.29999999. when we apply C truncation,
 1908// we want to end up with 1.3, not 1.2.
 1909inline void algo::value_qSetDouble(algo::I64Dec10& parent, double val) {
 1910    double intval = val * 10000000000 + (val > 0 ? 0.5 : -0.5);
 1911    // set underlying field.
 1912    parent.value = intval;
 1913}
 1914
 1915// --- algo.I64Dec10.value.GetDouble
 1916inline double algo::value_GetDouble(const algo::I64Dec10& parent) {
 1917    double ret;
 1918    ret = parent.value / double(10000000000);
 1919    return ret;
 1920}
 1921
 1922// --- algo.I64Dec10.value.GetInt
 1923// Return integer portion (divide number by 10000000000)
 1924inline i64 algo::value_GetInt(const algo::I64Dec10& parent) {
 1925    i64 ret;
 1926    ret = parent.value / 10000000000;
 1927    return ret;
 1928}
 1929
 1930// --- algo.I64Dec10.value.GetScale
 1931// Return constant 10000000000
 1932inline i64 algo::I64Dec10_GetScale() {
 1933    return 10000000000;
 1934}
 1935
 1936// --- algo.I64Dec10.value.Cast
 1937inline algo::I64Dec10::operator i64 () const {
 1938    return i64((*this).value);
 1939}
 1940
 1941// --- algo.I64Dec10..Hash
 1942inline u32 algo::I64Dec10_Hash(u32 prev, algo::I64Dec10 rhs) {
 1943    prev = i64_Hash(prev, rhs.value);
 1944    return prev;
 1945}
 1946
 1947// --- algo.I64Dec10..Init
 1948// Set all fields to initial values.
 1949inline void algo::I64Dec10_Init(algo::I64Dec10& parent) {
 1950    parent.value = i64(0);
 1951}
 1952inline algo::I64Dec2::I64Dec2(i64                            in_value)
 1953    : value(in_value)
 1954{
 1955}
 1956inline algo::I64Dec2::I64Dec2() {
 1957    algo::I64Dec2_Init(*this);
 1958}
 1959
 1960
 1961// --- algo.I64Dec2.value.qSetDouble
 1962// Set value of field value.
 1963// The value is rounded to the nearest integer.
 1964// This ensures that truncation of a near-integer value does not occur.
 1965// Example: 1.3 cannot be represented exactly as a double, the actual
 1966// stored value will be 1.29999999. when we apply C truncation,
 1967// we want to end up with 1.3, not 1.2.
 1968inline void algo::value_qSetDouble(algo::I64Dec2& parent, double val) {
 1969    double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
 1970    // set underlying field.
 1971    parent.value = intval;
 1972}
 1973
 1974// --- algo.I64Dec2.value.GetDouble
 1975inline double algo::value_GetDouble(const algo::I64Dec2& parent) {
 1976    double ret;
 1977    ret = parent.value / double(100);
 1978    return ret;
 1979}
 1980
 1981// --- algo.I64Dec2.value.GetInt
 1982// Return integer portion (divide number by 100)
 1983inline i64 algo::value_GetInt(const algo::I64Dec2& parent) {
 1984    i64 ret;
 1985    ret = parent.value / 100;
 1986    return ret;
 1987}
 1988
 1989// --- algo.I64Dec2.value.GetScale
 1990// Return constant 100
 1991inline i64 algo::I64Dec2_GetScale() {
 1992    return 100;
 1993}
 1994
 1995// --- algo.I64Dec2.value.Cast
 1996inline algo::I64Dec2::operator i64 () const {
 1997    return i64((*this).value);
 1998}
 1999
 2000// --- algo.I64Dec2..Hash
 2001inline u32 algo::I64Dec2_Hash(u32 prev, algo::I64Dec2 rhs) {
 2002    prev = i64_Hash(prev, rhs.value);
 2003    return prev;
 2004}
 2005
 2006// --- algo.I64Dec2..Init
 2007// Set all fields to initial values.
 2008inline void algo::I64Dec2_Init(algo::I64Dec2& parent) {
 2009    parent.value = i64(0);
 2010}
 2011inline algo::I64Dec3::I64Dec3(i64                            in_value)
 2012    : value(in_value)
 2013{
 2014}
 2015inline algo::I64Dec3::I64Dec3() {
 2016    algo::I64Dec3_Init(*this);
 2017}
 2018
 2019
 2020// --- algo.I64Dec3.value.qSetDouble
 2021// Set value of field value.
 2022// The value is rounded to the nearest integer.
 2023// This ensures that truncation of a near-integer value does not occur.
 2024// Example: 1.3 cannot be represented exactly as a double, the actual
 2025// stored value will be 1.29999999. when we apply C truncation,
 2026// we want to end up with 1.3, not 1.2.
 2027inline void algo::value_qSetDouble(algo::I64Dec3& parent, double val) {
 2028    double intval = val * 1000 + (val > 0 ? 0.5 : -0.5);
 2029    // set underlying field.
 2030    parent.value = intval;
 2031}
 2032
 2033// --- algo.I64Dec3.value.GetDouble
 2034inline double algo::value_GetDouble(const algo::I64Dec3& parent) {
 2035    double ret;
 2036    ret = parent.value / double(1000);
 2037    return ret;
 2038}
 2039
 2040// --- algo.I64Dec3.value.GetInt
 2041// Return integer portion (divide number by 1000)
 2042inline i64 algo::value_GetInt(const algo::I64Dec3& parent) {
 2043    i64 ret;
 2044    ret = parent.value / 1000;
 2045    return ret;
 2046}
 2047
 2048// --- algo.I64Dec3.value.GetScale
 2049// Return constant 1000
 2050inline i64 algo::I64Dec3_GetScale() {
 2051    return 1000;
 2052}
 2053
 2054// --- algo.I64Dec3.value.Cast
 2055inline algo::I64Dec3::operator i64 () const {
 2056    return i64((*this).value);
 2057}
 2058
 2059// --- algo.I64Dec3..Hash
 2060inline u32 algo::I64Dec3_Hash(u32 prev, algo::I64Dec3 rhs) {
 2061    prev = i64_Hash(prev, rhs.value);
 2062    return prev;
 2063}
 2064
 2065// --- algo.I64Dec3..Init
 2066// Set all fields to initial values.
 2067inline void algo::I64Dec3_Init(algo::I64Dec3& parent) {
 2068    parent.value = i64(0);
 2069}
 2070inline algo::I64Dec4::I64Dec4(i64                            in_value)
 2071    : value(in_value)
 2072{
 2073}
 2074inline algo::I64Dec4::I64Dec4() {
 2075    algo::I64Dec4_Init(*this);
 2076}
 2077
 2078
 2079// --- algo.I64Dec4.value.qSetDouble
 2080// Set value of field value.
 2081// The value is rounded to the nearest integer.
 2082// This ensures that truncation of a near-integer value does not occur.
 2083// Example: 1.3 cannot be represented exactly as a double, the actual
 2084// stored value will be 1.29999999. when we apply C truncation,
 2085// we want to end up with 1.3, not 1.2.
 2086inline void algo::value_qSetDouble(algo::I64Dec4& parent, double val) {
 2087    double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
 2088    // set underlying field.
 2089    parent.value = intval;
 2090}
 2091
 2092// --- algo.I64Dec4.value.GetDouble
 2093inline double algo::value_GetDouble(const algo::I64Dec4& parent) {
 2094    double ret;
 2095    ret = parent.value / double(10000);
 2096    return ret;
 2097}
 2098
 2099// --- algo.I64Dec4.value.GetInt
 2100// Return integer portion (divide number by 10000)
 2101inline i64 algo::value_GetInt(const algo::I64Dec4& parent) {
 2102    i64 ret;
 2103    ret = parent.value / 10000;
 2104    return ret;
 2105}
 2106
 2107// --- algo.I64Dec4.value.GetScale
 2108// Return constant 10000
 2109inline i64 algo::I64Dec4_GetScale() {
 2110    return 10000;
 2111}
 2112
 2113// --- algo.I64Dec4.value.Cast
 2114inline algo::I64Dec4::operator i64 () const {
 2115    return i64((*this).value);
 2116}
 2117
 2118// --- algo.I64Dec4..Hash
 2119inline u32 algo::I64Dec4_Hash(u32 prev, algo::I64Dec4 rhs) {
 2120    prev = i64_Hash(prev, rhs.value);
 2121    return prev;
 2122}
 2123
 2124// --- algo.I64Dec4..Init
 2125// Set all fields to initial values.
 2126inline void algo::I64Dec4_Init(algo::I64Dec4& parent) {
 2127    parent.value = i64(0);
 2128}
 2129inline algo::I64Dec5::I64Dec5(i64                            in_value)
 2130    : value(in_value)
 2131{
 2132}
 2133inline algo::I64Dec5::I64Dec5() {
 2134    algo::I64Dec5_Init(*this);
 2135}
 2136
 2137
 2138// --- algo.I64Dec5.value.qSetDouble
 2139// Set value of field value.
 2140// The value is rounded to the nearest integer.
 2141// This ensures that truncation of a near-integer value does not occur.
 2142// Example: 1.3 cannot be represented exactly as a double, the actual
 2143// stored value will be 1.29999999. when we apply C truncation,
 2144// we want to end up with 1.3, not 1.2.
 2145inline void algo::value_qSetDouble(algo::I64Dec5& parent, double val) {
 2146    double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
 2147    // set underlying field.
 2148    parent.value = intval;
 2149}
 2150
 2151// --- algo.I64Dec5.value.GetDouble
 2152inline double algo::value_GetDouble(const algo::I64Dec5& parent) {
 2153    double ret;
 2154    ret = parent.value / double(100000);
 2155    return ret;
 2156}
 2157
 2158// --- algo.I64Dec5.value.GetInt
 2159// Return integer portion (divide number by 100000)
 2160inline i64 algo::value_GetInt(const algo::I64Dec5& parent) {
 2161    i64 ret;
 2162    ret = parent.value / 100000;
 2163    return ret;
 2164}
 2165
 2166// --- algo.I64Dec5.value.GetScale
 2167// Return constant 100000
 2168inline i64 algo::I64Dec5_GetScale() {
 2169    return 100000;
 2170}
 2171
 2172// --- algo.I64Dec5.value.Cast
 2173inline algo::I64Dec5::operator i64 () const {
 2174    return i64((*this).value);
 2175}
 2176
 2177// --- algo.I64Dec5..Hash
 2178inline u32 algo::I64Dec5_Hash(u32 prev, algo::I64Dec5 rhs) {
 2179    prev = i64_Hash(prev, rhs.value);
 2180    return prev;
 2181}
 2182
 2183// --- algo.I64Dec5..Init
 2184// Set all fields to initial values.
 2185inline void algo::I64Dec5_Init(algo::I64Dec5& parent) {
 2186    parent.value = i64(0);
 2187}
 2188inline algo::I64Dec6::I64Dec6(i64                            in_value)
 2189    : value(in_value)
 2190{
 2191}
 2192inline algo::I64Dec6::I64Dec6() {
 2193    algo::I64Dec6_Init(*this);
 2194}
 2195
 2196
 2197// --- algo.I64Dec6.value.qSetDouble
 2198// Set value of field value.
 2199// The value is rounded to the nearest integer.
 2200// This ensures that truncation of a near-integer value does not occur.
 2201// Example: 1.3 cannot be represented exactly as a double, the actual
 2202// stored value will be 1.29999999. when we apply C truncation,
 2203// we want to end up with 1.3, not 1.2.
 2204inline void algo::value_qSetDouble(algo::I64Dec6& parent, double val) {
 2205    double intval = val * 1000000 + (val > 0 ? 0.5 : -0.5);
 2206    // set underlying field.
 2207    parent.value = intval;
 2208}
 2209
 2210// --- algo.I64Dec6.value.GetDouble
 2211inline double algo::value_GetDouble(const algo::I64Dec6& parent) {
 2212    double ret;
 2213    ret = parent.value / double(1000000);
 2214    return ret;
 2215}
 2216
 2217// --- algo.I64Dec6.value.GetInt
 2218// Return integer portion (divide number by 1000000)
 2219inline i64 algo::value_GetInt(const algo::I64Dec6& parent) {
 2220    i64 ret;
 2221    ret = parent.value / 1000000;
 2222    return ret;
 2223}
 2224
 2225// --- algo.I64Dec6.value.GetScale
 2226// Return constant 1000000
 2227inline i64 algo::I64Dec6_GetScale() {
 2228    return 1000000;
 2229}
 2230
 2231// --- algo.I64Dec6.value.Cast
 2232inline algo::I64Dec6::operator i64 () const {
 2233    return i64((*this).value);
 2234}
 2235
 2236// --- algo.I64Dec6..Hash
 2237inline u32 algo::I64Dec6_Hash(u32 prev, algo::I64Dec6 rhs) {
 2238    prev = i64_Hash(prev, rhs.value);
 2239    return prev;
 2240}
 2241
 2242// --- algo.I64Dec6..Init
 2243// Set all fields to initial values.
 2244inline void algo::I64Dec6_Init(algo::I64Dec6& parent) {
 2245    parent.value = i64(0);
 2246}
 2247inline algo::I64Dec7::I64Dec7(i64                            in_value)
 2248    : value(in_value)
 2249{
 2250}
 2251inline algo::I64Dec7::I64Dec7() {
 2252    algo::I64Dec7_Init(*this);
 2253}
 2254
 2255
 2256// --- algo.I64Dec7.value.qSetDouble
 2257// Set value of field value.
 2258// The value is rounded to the nearest integer.
 2259// This ensures that truncation of a near-integer value does not occur.
 2260// Example: 1.3 cannot be represented exactly as a double, the actual
 2261// stored value will be 1.29999999. when we apply C truncation,
 2262// we want to end up with 1.3, not 1.2.
 2263inline void algo::value_qSetDouble(algo::I64Dec7& parent, double val) {
 2264    double intval = val * 10000000 + (val > 0 ? 0.5 : -0.5);
 2265    // set underlying field.
 2266    parent.value = intval;
 2267}
 2268
 2269// --- algo.I64Dec7.value.GetDouble
 2270inline double algo::value_GetDouble(const algo::I64Dec7& parent) {
 2271    double ret;
 2272    ret = parent.value / double(10000000);
 2273    return ret;
 2274}
 2275
 2276// --- algo.I64Dec7.value.GetInt
 2277// Return integer portion (divide number by 10000000)
 2278inline i64 algo::value_GetInt(const algo::I64Dec7& parent) {
 2279    i64 ret;
 2280    ret = parent.value / 10000000;
 2281    return ret;
 2282}
 2283
 2284// --- algo.I64Dec7.value.GetScale
 2285// Return constant 10000000
 2286inline i64 algo::I64Dec7_GetScale() {
 2287    return 10000000;
 2288}
 2289
 2290// --- algo.I64Dec7.value.Cast
 2291inline algo::I64Dec7::operator i64 () const {
 2292    return i64((*this).value);
 2293}
 2294
 2295// --- algo.I64Dec7..Hash
 2296inline u32 algo::I64Dec7_Hash(u32 prev, algo::I64Dec7 rhs) {
 2297    prev = i64_Hash(prev, rhs.value);
 2298    return prev;
 2299}
 2300
 2301// --- algo.I64Dec7..Init
 2302// Set all fields to initial values.
 2303inline void algo::I64Dec7_Init(algo::I64Dec7& parent) {
 2304    parent.value = i64(0);
 2305}
 2306inline algo::I64Dec8::I64Dec8(i64                            in_value)
 2307    : value(in_value)
 2308{
 2309}
 2310inline algo::I64Dec8::I64Dec8() {
 2311    algo::I64Dec8_Init(*this);
 2312}
 2313
 2314
 2315// --- algo.I64Dec8.value.qSetDouble
 2316// Set value of field value.
 2317// The value is rounded to the nearest integer.
 2318// This ensures that truncation of a near-integer value does not occur.
 2319// Example: 1.3 cannot be represented exactly as a double, the actual
 2320// stored value will be 1.29999999. when we apply C truncation,
 2321// we want to end up with 1.3, not 1.2.
 2322inline void algo::value_qSetDouble(algo::I64Dec8& parent, double val) {
 2323    double intval = val * 100000000 + (val > 0 ? 0.5 : -0.5);
 2324    // set underlying field.
 2325    parent.value = intval;
 2326}
 2327
 2328// --- algo.I64Dec8.value.GetDouble
 2329inline double algo::value_GetDouble(const algo::I64Dec8& parent) {
 2330    double ret;
 2331    ret = parent.value / double(100000000);
 2332    return ret;
 2333}
 2334
 2335// --- algo.I64Dec8.value.GetInt
 2336// Return integer portion (divide number by 100000000)
 2337inline i64 algo::value_GetInt(const algo::I64Dec8& parent) {
 2338    i64 ret;
 2339    ret = parent.value / 100000000;
 2340    return ret;
 2341}
 2342
 2343// --- algo.I64Dec8.value.GetScale
 2344// Return constant 100000000
 2345inline i64 algo::I64Dec8_GetScale() {
 2346    return 100000000;
 2347}
 2348
 2349// --- algo.I64Dec8.value.Cast
 2350inline algo::I64Dec8::operator i64 () const {
 2351    return i64((*this).value);
 2352}
 2353
 2354// --- algo.I64Dec8..Hash
 2355inline u32 algo::I64Dec8_Hash(u32 prev, algo::I64Dec8 rhs) {
 2356    prev = i64_Hash(prev, rhs.value);
 2357    return prev;
 2358}
 2359
 2360// --- algo.I64Dec8..Init
 2361// Set all fields to initial values.
 2362inline void algo::I64Dec8_Init(algo::I64Dec8& parent) {
 2363    parent.value = i64(0);
 2364}
 2365inline algo::I64Dec9::I64Dec9(i64                            in_value)
 2366    : value(in_value)
 2367{
 2368}
 2369inline algo::I64Dec9::I64Dec9() {
 2370    algo::I64Dec9_Init(*this);
 2371}
 2372
 2373
 2374// --- algo.I64Dec9.value.qSetDouble
 2375// Set value of field value.
 2376// The value is rounded to the nearest integer.
 2377// This ensures that truncation of a near-integer value does not occur.
 2378// Example: 1.3 cannot be represented exactly as a double, the actual
 2379// stored value will be 1.29999999. when we apply C truncation,
 2380// we want to end up with 1.3, not 1.2.
 2381inline void algo::value_qSetDouble(algo::I64Dec9& parent, double val) {
 2382    double intval = val * 1000000000 + (val > 0 ? 0.5 : -0.5);
 2383    // set underlying field.
 2384    parent.value = intval;
 2385}
 2386
 2387// --- algo.I64Dec9.value.GetDouble
 2388inline double algo::value_GetDouble(const algo::I64Dec9& parent) {
 2389    double ret;
 2390    ret = parent.value / double(1000000000);
 2391    return ret;
 2392}
 2393
 2394// --- algo.I64Dec9.value.GetInt
 2395// Return integer portion (divide number by 1000000000)
 2396inline i64 algo::value_GetInt(const algo::I64Dec9& parent) {
 2397    i64 ret;
 2398    ret = parent.value / 1000000000;
 2399    return ret;
 2400}
 2401
 2402// --- algo.I64Dec9.value.GetScale
 2403// Return constant 1000000000
 2404inline i64 algo::I64Dec9_GetScale() {
 2405    return 1000000000;
 2406}
 2407
 2408// --- algo.I64Dec9.value.Cast
 2409inline algo::I64Dec9::operator i64 () const {
 2410    return i64((*this).value);
 2411}
 2412
 2413// --- algo.I64Dec9..Hash
 2414inline u32 algo::I64Dec9_Hash(u32 prev, algo::I64Dec9 rhs) {
 2415    prev = i64_Hash(prev, rhs.value);
 2416    return prev;
 2417}
 2418
 2419// --- algo.I64Dec9..Init
 2420// Set all fields to initial values.
 2421inline void algo::I64Dec9_Init(algo::I64Dec9& parent) {
 2422    parent.value = i64(0);
 2423}
 2424inline algo::IOEvtFlags::IOEvtFlags(u32                            in_value)
 2425    : value(in_value)
 2426{
 2427}
 2428inline algo::IOEvtFlags::IOEvtFlags(algo_IOEvtFlagsEnum arg) { this->value = u32(arg); }
 2429inline algo::IOEvtFlags::IOEvtFlags() {
 2430    algo::IOEvtFlags_Init(*this);
 2431}
 2432
 2433
 2434// --- algo.IOEvtFlags.value.Cast
 2435inline algo::IOEvtFlags::operator algo_IOEvtFlagsEnum () const {
 2436    return algo_IOEvtFlagsEnum((*this).value);
 2437}
 2438
 2439// --- algo.IOEvtFlags.read.Get
 2440// Retrieve bitfield from value of field value
 2441//    1 bits starting at bit 0.
 2442inline bool algo::read_Get(const algo::IOEvtFlags& parent) {
 2443    return bool((parent.value >> 0) & 0x01);
 2444}
 2445
 2446// --- algo.IOEvtFlags.read.Set
 2447// Set bitfield in value of field 'value'
 2448//    1 bits starting at bit 0.
 2449inline void algo::read_Set(algo::IOEvtFlags& parent, bool rhs) {
 2450    u32 t1    = u32(0x01) << 0;
 2451    u32 t2    = (u32(rhs) & 0x01) << 0;
 2452    parent.value = u32((parent.value & ~t1) | t2);
 2453}
 2454
 2455// --- algo.IOEvtFlags.write.Get
 2456// Retrieve bitfield from value of field value
 2457//    1 bits starting at bit 1.
 2458inline bool algo::write_Get(const algo::IOEvtFlags& parent) {
 2459    return bool((parent.value >> 1) & 0x01);
 2460}
 2461
 2462// --- algo.IOEvtFlags.write.Set
 2463// Set bitfield in value of field 'value'
 2464//    1 bits starting at bit 1.
 2465inline void algo::write_Set(algo::IOEvtFlags& parent, bool rhs) {
 2466    u32 t1    = u32(0x01) << 1;
 2467    u32 t2    = (u32(rhs) & 0x01) << 1;
 2468    parent.value = u32((parent.value & ~t1) | t2);
 2469}
 2470
 2471// --- algo.IOEvtFlags.eof.Get
 2472// Retrieve bitfield from value of field value
 2473//    1 bits starting at bit 2.
 2474inline bool algo::eof_Get(const algo::IOEvtFlags& parent) {
 2475    return bool((parent.value >> 2) & 0x01);
 2476}
 2477
 2478// --- algo.IOEvtFlags.eof.Set
 2479// Set bitfield in value of field 'value'
 2480//    1 bits starting at bit 2.
 2481inline void algo::eof_Set(algo::IOEvtFlags& parent, bool rhs) {
 2482    u32 t1    = u32(0x01) << 2;
 2483    u32 t2    = (u32(rhs) & 0x01) << 2;
 2484    parent.value = u32((parent.value & ~t1) | t2);
 2485}
 2486
 2487// --- algo.IOEvtFlags.err.Get
 2488// Retrieve bitfield from value of field value
 2489//    1 bits starting at bit 3.
 2490inline bool algo::err_Get(const algo::IOEvtFlags& parent) {
 2491    return bool((parent.value >> 3) & 0x01);
 2492}
 2493
 2494// --- algo.IOEvtFlags.err.Set
 2495// Set bitfield in value of field 'value'
 2496//    1 bits starting at bit 3.
 2497inline void algo::err_Set(algo::IOEvtFlags& parent, bool rhs) {
 2498    u32 t1    = u32(0x01) << 3;
 2499    u32 t2    = (u32(rhs) & 0x01) << 3;
 2500    parent.value = u32((parent.value & ~t1) | t2);
 2501}
 2502
 2503// --- algo.IOEvtFlags..Init
 2504// Set all fields to initial values.
 2505inline void algo::IOEvtFlags_Init(algo::IOEvtFlags& parent) {
 2506    parent.value = u32(0);
 2507}
 2508inline algo::IPoint::IPoint() {
 2509    algo::IPoint_Init(*this);
 2510}
 2511
 2512
 2513// --- algo.IPoint..Init
 2514// Set all fields to initial values.
 2515inline void algo::IPoint_Init(algo::IPoint& parent) {
 2516    parent.x = i32(0);
 2517    parent.y = i32(0);
 2518}
 2519
 2520inline bool algo::Smallstr50::operator ==(const algo::Smallstr50 &rhs) const {
 2521    return algo::Smallstr50_Eq(const_cast<algo::Smallstr50&>(*this),const_cast<algo::Smallstr50&>(rhs));
 2522}
 2523
 2524inline bool algo::Smallstr50::operator !=(const algo::Smallstr50 &rhs) const {
 2525    return !algo::Smallstr50_Eq(const_cast<algo::Smallstr50&>(*this),const_cast<algo::Smallstr50&>(rhs));
 2526}
 2527
 2528inline bool algo::Smallstr50::operator ==(const algo::strptr &rhs) const {
 2529    return algo::Smallstr50_EqStrptr(const_cast<algo::Smallstr50&>(*this),rhs);
 2530}
 2531
 2532inline bool algo::Smallstr50::operator <(const algo::Smallstr50 &rhs) const {
 2533    return algo::Smallstr50_Lt(const_cast<algo::Smallstr50&>(*this),const_cast<algo::Smallstr50&>(rhs));
 2534}
 2535
 2536inline bool algo::Smallstr50::operator >(const algo::Smallstr50 &rhs) const {
 2537    return rhs < *this;
 2538}
 2539
 2540inline bool algo::Smallstr50::operator <=(const algo::Smallstr50 &rhs) const {
 2541    return !(rhs < *this);
 2542}
 2543
 2544inline bool algo::Smallstr50::operator >=(const algo::Smallstr50 &rhs) const {
 2545    return !(*this < rhs);
 2546}
 2547inline algo::Smallstr50::Smallstr50() {
 2548    algo::Smallstr50_Init(*this);
 2549}
 2550
 2551
 2552// --- algo.Smallstr50.ch.Add
 2553// Append character to string.
 2554// If there is no space for an extra character, do nothing.
 2555inline void algo::ch_Add(algo::Smallstr50& parent, char c) {
 2556    if (parent.n_ch < 50) {
 2557        parent.ch[parent.n_ch++] = c;
 2558    }
 2559}
 2560
 2561// --- algo.Smallstr50.ch.AddStrptr
 2562// Append string to this string.
 2563// If there is no space for an extra character, trim.
 2564// If there is no space left, dump core in debug mode.
 2565inline void algo::ch_AddStrptr(algo::Smallstr50& parent, algo::strptr str) {
 2566    int n_new = str.n_elems;
 2567    if (parent.n_ch + n_new > 50) {
 2568        n_new = 50 - parent.n_ch;
 2569    }
 2570    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
 2571    parent.n_ch = u8(parent.n_ch + n_new);
 2572}
 2573
 2574// --- algo.Smallstr50.ch.Getary
 2575// Access string as array of chars
 2576inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr50& parent) {
 2577    int len = ch_N(parent);
 2578    algo::aryptr<char> ret((char*)parent.ch, len);
 2579    return ret;
 2580}
 2581
 2582// --- algo.Smallstr50.ch.HashStrptr
 2583inline u32 algo::Smallstr50_Hash(u32 prev, const algo::strptr &str) {
 2584    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 2585}
 2586
 2587// --- algo.Smallstr50.ch.Init
 2588inline void algo::ch_Init(algo::Smallstr50 &parent) {
 2589    parent.n_ch = 0;
 2590}
 2591
 2592// --- algo.Smallstr50.ch.Max
 2593// always return constant 50
 2594inline int algo::ch_Max(algo::Smallstr50& parent) {
 2595    (void)parent;
 2596    return 50;
 2597}
 2598
 2599// --- algo.Smallstr50.ch.N
 2600inline int algo::ch_N(const algo::Smallstr50& parent) {
 2601    u64 ret;
 2602    ret = parent.n_ch;
 2603    return int(ret);
 2604}
 2605
 2606// --- algo.Smallstr50.ch.AssignStrptr
 2607// Copy from strptr (operator=)
 2608inline void algo::Smallstr50::operator =(const algo::strptr &str) {
 2609    ch_SetStrptr(*this, str);
 2610}
 2611
 2612// --- algo.Smallstr50.ch.Set
 2613// Copy from same type
 2614// Copy value from RHS.
 2615inline void algo::Smallstr50::operator =(const algo::Smallstr50& parent) {
 2616    memcpy(ch, parent.ch, parent.n_ch);
 2617    n_ch = parent.n_ch;
 2618}
 2619
 2620// --- algo.Smallstr50.ch.Ctor
 2621inline  algo::Smallstr50::Smallstr50(const algo::Smallstr50 &rhs) {
 2622    operator =(rhs);
 2623}
 2624
 2625// --- algo.Smallstr50.ch.CtorStrptr
 2626inline  algo::Smallstr50::Smallstr50(const algo::strptr &rhs) {
 2627    ch_SetStrptr(*this, rhs);
 2628}
 2629
 2630// --- algo.Smallstr50.ch.Cast
 2631inline algo::Smallstr50::operator algo::strptr () const {
 2632    return ch_Getary(*this);
 2633}
 2634
 2635// --- algo.Smallstr50..Lt
 2636inline bool algo::Smallstr50_Lt(algo::Smallstr50& lhs, algo::Smallstr50& rhs) {
 2637    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 2638}
 2639
 2640// --- algo.Smallstr50..Cmp
 2641inline i32 algo::Smallstr50_Cmp(algo::Smallstr50& lhs, algo::Smallstr50& rhs) {
 2642    i32 retval = 0;
 2643    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 2644    return retval;
 2645}
 2646
 2647// --- algo.Smallstr50..Init
 2648// Set all fields to initial values.
 2649inline void algo::Smallstr50_Init(algo::Smallstr50& parent) {
 2650    parent.n_ch = 0;
 2651}
 2652
 2653// --- algo.Smallstr50..Eq
 2654inline bool algo::Smallstr50_Eq(algo::Smallstr50& lhs, algo::Smallstr50& rhs) {
 2655    bool retval = true;
 2656    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
 2657    return retval;
 2658}
 2659
 2660// --- algo.Smallstr50..Update
 2661// Set value. Return true if new value is different from old value.
 2662inline bool algo::Smallstr50_Update(algo::Smallstr50 &lhs, algo::Smallstr50& rhs) {
 2663    bool ret = !Smallstr50_Eq(lhs, rhs); // compare values
 2664    if (ret) {
 2665        lhs = rhs; // update
 2666    }
 2667    return ret;
 2668}
 2669
 2670// --- algo.Smallstr50..EqStrptr
 2671inline bool algo::Smallstr50_EqStrptr(const algo::Smallstr50& lhs, const algo::strptr& rhs) {
 2672    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 2673}
 2674inline algo::Imdb::Imdb(const algo::strptr&            in_imdb
 2675        ,const algo::ImdbInsertStrptrMaybeFcn& in_InsertStrptrMaybe
 2676        ,const algo::ImdbStepFcn&       in_Step
 2677        ,const algo::ImdbMainLoopFcn&   in_MainLoop
 2678        ,const algo::ImdbGetTraceFcn&   in_GetTrace
 2679        ,const algo::Comment&           in_comment)
 2680    : imdb(in_imdb)
 2681    , InsertStrptrMaybe(in_InsertStrptrMaybe)
 2682    , Step(in_Step)
 2683    , MainLoop(in_MainLoop)
 2684    , GetTrace(in_GetTrace)
 2685    , comment(in_comment)
 2686{
 2687}
 2688inline algo::Imdb::Imdb() {
 2689    algo::Imdb_Init(*this);
 2690}
 2691
 2692
 2693// --- algo.Imdb..Init
 2694// Set all fields to initial values.
 2695inline void algo::Imdb_Init(algo::Imdb& parent) {
 2696    memset(&parent.InsertStrptrMaybe, 0, sizeof(parent.InsertStrptrMaybe));
 2697    memset(&parent.Step, 0, sizeof(parent.Step));
 2698    memset(&parent.MainLoop, 0, sizeof(parent.MainLoop));
 2699    memset(&parent.GetTrace, 0, sizeof(parent.GetTrace));
 2700}
 2701inline algo::ImrowPtr::ImrowPtr(u64                            in_value)
 2702    : value(in_value)
 2703{
 2704}
 2705inline algo::ImrowPtr::ImrowPtr() {
 2706    algo::ImrowPtr_Init(*this);
 2707}
 2708
 2709
 2710// --- algo.ImrowPtr.value.Cast
 2711inline algo::ImrowPtr::operator u64 () const {
 2712    return u64((*this).value);
 2713}
 2714
 2715// --- algo.ImrowPtr..Init
 2716// Set all fields to initial values.
 2717inline void algo::ImrowPtr_Init(algo::ImrowPtr& parent) {
 2718    parent.value = u64(0);
 2719}
 2720inline algo::Smallstr100::Smallstr100() {
 2721    algo::Smallstr100_Init(*this);
 2722}
 2723
 2724
 2725// --- algo.Smallstr100.ch.Add
 2726// Append character to string.
 2727// If there is no space for an extra character, do nothing.
 2728inline void algo::ch_Add(algo::Smallstr100& parent, char c) {
 2729    if (parent.n_ch < 100) {
 2730        parent.ch[parent.n_ch++] = c;
 2731    }
 2732}
 2733
 2734// --- algo.Smallstr100.ch.AddStrptr
 2735// Append string to this string.
 2736// If there is no space for an extra character, trim.
 2737// If there is no space left, dump core in debug mode.
 2738inline void algo::ch_AddStrptr(algo::Smallstr100& parent, algo::strptr str) {
 2739    int n_new = str.n_elems;
 2740    if (parent.n_ch + n_new > 100) {
 2741        n_new = 100 - parent.n_ch;
 2742    }
 2743    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
 2744    parent.n_ch = u8(parent.n_ch + n_new);
 2745}
 2746
 2747// --- algo.Smallstr100.ch.Getary
 2748// Access string as array of chars
 2749inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr100& parent) {
 2750    int len = ch_N(parent);
 2751    algo::aryptr<char> ret((char*)parent.ch, len);
 2752    return ret;
 2753}
 2754
 2755// --- algo.Smallstr100.ch.HashStrptr
 2756inline u32 algo::Smallstr100_Hash(u32 prev, const algo::strptr &str) {
 2757    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 2758}
 2759
 2760// --- algo.Smallstr100.ch.Init
 2761inline void algo::ch_Init(algo::Smallstr100 &parent) {
 2762    parent.n_ch = 0;
 2763}
 2764
 2765// --- algo.Smallstr100.ch.Max
 2766// always return constant 100
 2767inline int algo::ch_Max(algo::Smallstr100& parent) {
 2768    (void)parent;
 2769    return 100;
 2770}
 2771
 2772// --- algo.Smallstr100.ch.N
 2773inline int algo::ch_N(const algo::Smallstr100& parent) {
 2774    u64 ret;
 2775    ret = parent.n_ch;
 2776    return int(ret);
 2777}
 2778
 2779// --- algo.Smallstr100.ch.AssignStrptr
 2780// Copy from strptr (operator=)
 2781inline void algo::Smallstr100::operator =(const algo::strptr &str) {
 2782    ch_SetStrptr(*this, str);
 2783}
 2784
 2785// --- algo.Smallstr100.ch.Set
 2786// Copy from same type
 2787// Copy value from RHS.
 2788inline void algo::Smallstr100::operator =(const algo::Smallstr100& parent) {
 2789    memcpy(ch, parent.ch, parent.n_ch);
 2790    n_ch = parent.n_ch;
 2791}
 2792
 2793// --- algo.Smallstr100.ch.Ctor
 2794inline  algo::Smallstr100::Smallstr100(const algo::Smallstr100 &rhs) {
 2795    operator =(rhs);
 2796}
 2797
 2798// --- algo.Smallstr100.ch.CtorStrptr
 2799inline  algo::Smallstr100::Smallstr100(const algo::strptr &rhs) {
 2800    ch_SetStrptr(*this, rhs);
 2801}
 2802
 2803// --- algo.Smallstr100.ch.Cast
 2804inline algo::Smallstr100::operator algo::strptr () const {
 2805    return ch_Getary(*this);
 2806}
 2807
 2808// --- algo.Smallstr100..Cmp
 2809inline i32 algo::Smallstr100_Cmp(algo::Smallstr100& lhs, algo::Smallstr100& rhs) {
 2810    i32 retval = 0;
 2811    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 2812    return retval;
 2813}
 2814
 2815// --- algo.Smallstr100..Init
 2816// Set all fields to initial values.
 2817inline void algo::Smallstr100_Init(algo::Smallstr100& parent) {
 2818    parent.n_ch = 0;
 2819}
 2820
 2821// --- algo.Smallstr100..Eq
 2822inline bool algo::Smallstr100_Eq(algo::Smallstr100& lhs, algo::Smallstr100& rhs) {
 2823    bool retval = true;
 2824    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
 2825    return retval;
 2826}
 2827
 2828// --- algo.Smallstr100..EqStrptr
 2829inline bool algo::Smallstr100_EqStrptr(const algo::Smallstr100& lhs, const algo::strptr& rhs) {
 2830    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 2831}
 2832inline algo::Imtable::Imtable(const algo::strptr&            in_imtable
 2833        ,const algo::strptr&            in_elem_type
 2834        ,const algo::ImrowRowidFindFcn& in_c_RowidFind
 2835        ,const algo::ImrowXrefXFcn&     in_XrefX
 2836        ,const algo::ImrowNItemsFcn&    in_NItems
 2837        ,const algo::ImrowPrintFcn&     in_Print
 2838        ,i32                            in_size
 2839        ,const algo::strptr&            in_ssimfile
 2840        ,const algo::Comment&           in_comment)
 2841    : imtable(in_imtable)
 2842    , elem_type(in_elem_type)
 2843    , c_RowidFind(in_c_RowidFind)
 2844    , XrefX(in_XrefX)
 2845    , NItems(in_NItems)
 2846    , Print(in_Print)
 2847    , size(in_size)
 2848    , ssimfile(in_ssimfile)
 2849    , comment(in_comment)
 2850{
 2851}
 2852inline algo::Imtable::Imtable() {
 2853    algo::Imtable_Init(*this);
 2854}
 2855
 2856
 2857// --- algo.Imtable..Init
 2858// Set all fields to initial values.
 2859inline void algo::Imtable_Init(algo::Imtable& parent) {
 2860    memset(&parent.c_RowidFind, 0, sizeof(parent.c_RowidFind));
 2861    memset(&parent.XrefX, 0, sizeof(parent.XrefX));
 2862    memset(&parent.NItems, 0, sizeof(parent.NItems));
 2863    memset(&parent.Print, 0, sizeof(parent.Print));
 2864    parent.size = i32(0);
 2865}
 2866inline algo::Ipmask::Ipmask() {
 2867    algo::Ipmask_Init(*this);
 2868}
 2869
 2870
 2871// --- algo.Ipmask..Init
 2872// Set all fields to initial values.
 2873inline void algo::Ipmask_Init(algo::Ipmask& parent) {
 2874    parent.ip_host = u32(0);
 2875    parent.mask = u32(0);
 2876}
 2877
 2878// --- algo.strptr..Update
 2879// Set value. Return true if new value is different from old value.
 2880inline bool algo::strptr_Update(algo::strptr &lhs, algo::strptr rhs) {
 2881    bool ret = !strptr_Eq(lhs, rhs); // compare values
 2882    if (ret) {
 2883        lhs = rhs; // update
 2884    }
 2885    return ret;
 2886}
 2887inline algo::LineBuf::LineBuf() {
 2888    algo::LineBuf_Init(*this);
 2889}
 2890
 2891inline algo::LineBuf::~LineBuf() {
 2892    algo::LineBuf_Uninit(*this);
 2893}
 2894
 2895
 2896// --- algo.LineBuf.buf.EmptyQ
 2897// Return true if index is empty
 2898inline bool algo::buf_EmptyQ(algo::LineBuf& parent) {
 2899    return parent.buf_n == 0;
 2900}
 2901
 2902// --- algo.LineBuf.buf.Find
 2903// Look up row by row id. Return NULL if out of range
 2904inline char* algo::buf_Find(algo::LineBuf& parent, u64 t) {
 2905    u64 idx = t;
 2906    u64 lim = parent.buf_n;
 2907    if (idx >= lim) return NULL;
 2908    return parent.buf_elems + idx;
 2909}
 2910
 2911// --- algo.LineBuf.buf.Getary
 2912// Return array pointer by value
 2913inline algo::aryptr<char> algo::buf_Getary(const algo::LineBuf& parent) {
 2914    return algo::aryptr<char>(parent.buf_elems, parent.buf_n);
 2915}
 2916
 2917// --- algo.LineBuf.buf.Last
 2918// Return pointer to last element of array, or NULL if array is empty
 2919inline char* algo::buf_Last(algo::LineBuf& parent) {
 2920    return buf_Find(parent, u64(parent.buf_n-1));
 2921}
 2922
 2923// --- algo.LineBuf.buf.Max
 2924// Return max. number of items in the array
 2925inline i32 algo::buf_Max(algo::LineBuf& parent) {
 2926    (void)parent;
 2927    return parent.buf_max;
 2928}
 2929
 2930// --- algo.LineBuf.buf.N
 2931// Return number of items in the array
 2932inline i32 algo::buf_N(const algo::LineBuf& parent) {
 2933    return parent.buf_n;
 2934}
 2935
 2936// --- algo.LineBuf.buf.RemoveAll
 2937inline void algo::buf_RemoveAll(algo::LineBuf& parent) {
 2938    parent.buf_n = 0;
 2939}
 2940
 2941// --- algo.LineBuf.buf.Reserve
 2942// Make sure N *more* elements will fit in array. Process dies if out of memory
 2943inline void algo::buf_Reserve(algo::LineBuf& parent, int n) {
 2944    u32 new_n = parent.buf_n + n;
 2945    if (UNLIKELY(new_n > parent.buf_max)) {
 2946        buf_AbsReserve(parent, new_n);
 2947    }
 2948}
 2949
 2950// --- algo.LineBuf.buf.qFind
 2951// 'quick' Access row by row id. No bounds checking.
 2952inline char& algo::buf_qFind(algo::LineBuf& parent, u64 t) {
 2953    return parent.buf_elems[t];
 2954}
 2955
 2956// --- algo.LineBuf.buf.qLast
 2957// Return reference to last element of array. No bounds checking
 2958inline char& algo::buf_qLast(algo::LineBuf& parent) {
 2959    return buf_qFind(parent, u64(parent.buf_n-1));
 2960}
 2961
 2962// --- algo.LineBuf.buf.rowid_Get
 2963// Return row id of specified element
 2964inline u64 algo::buf_rowid_Get(algo::LineBuf& parent, char &elem) {
 2965    u64 id = &elem - parent.buf_elems;
 2966    return u64(id);
 2967}
 2968
 2969// --- algo.LineBuf.buf_curs.Next
 2970// proceed to next item
 2971inline void algo::LineBuf_buf_curs_Next(LineBuf_buf_curs &curs) {
 2972    curs.index++;
 2973}
 2974
 2975// --- algo.LineBuf.buf_curs.Reset
 2976inline void algo::LineBuf_buf_curs_Reset(LineBuf_buf_curs &curs, algo::LineBuf &parent) {
 2977    curs.elems = parent.buf_elems;
 2978    curs.n_elems = parent.buf_n;
 2979    curs.index = 0;
 2980}
 2981
 2982// --- algo.LineBuf.buf_curs.ValidQ
 2983// cursor points to valid item
 2984inline bool algo::LineBuf_buf_curs_ValidQ(LineBuf_buf_curs &curs) {
 2985    return curs.index < curs.n_elems;
 2986}
 2987
 2988// --- algo.LineBuf.buf_curs.Access
 2989// item access
 2990inline char& algo::LineBuf_buf_curs_Access(LineBuf_buf_curs &curs) {
 2991    return curs.elems[curs.index];
 2992}
 2993
 2994// --- algo.LineBuf..Init
 2995// Set all fields to initial values.
 2996inline void algo::LineBuf_Init(algo::LineBuf& parent) {
 2997    parent.buf_elems 	= 0; // (algo.LineBuf.buf)
 2998    parent.buf_n     	= 0; // (algo.LineBuf.buf)
 2999    parent.buf_max   	= 0; // (algo.LineBuf.buf)
 3000    parent.implied_eof = bool(false);
 3001    parent.eof = bool(false);
 3002}
 3003
 3004inline bool algo::LnumStr10_U64::operator ==(const algo::LnumStr10_U64 &rhs) const {
 3005    return algo::LnumStr10_U64_Eq(const_cast<algo::LnumStr10_U64&>(*this),const_cast<algo::LnumStr10_U64&>(rhs));
 3006}
 3007
 3008inline bool algo::LnumStr10_U64::operator !=(const algo::LnumStr10_U64 &rhs) const {
 3009    return !algo::LnumStr10_U64_Eq(const_cast<algo::LnumStr10_U64&>(*this),const_cast<algo::LnumStr10_U64&>(rhs));
 3010}
 3011
 3012inline bool algo::LnumStr10_U64::operator ==(const algo::strptr &rhs) const {
 3013    return algo::LnumStr10_U64_EqStrptr(const_cast<algo::LnumStr10_U64&>(*this),rhs);
 3014}
 3015inline algo::LnumStr10_U64::LnumStr10_U64() {
 3016    algo::LnumStr10_U64_Init(*this);
 3017}
 3018
 3019
 3020// --- algo.LnumStr10_U64.ch.Getary
 3021// Access string as array of chars
 3022inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr10_U64& parent) {
 3023    int len = ch_N(parent);
 3024    algo::aryptr<char> ret((char*)parent.ch, len);
 3025    ret.elems += 10 - len;
 3026    return ret;
 3027}
 3028
 3029// --- algo.LnumStr10_U64.ch.HashStrptr
 3030inline u32 algo::LnumStr10_U64_Hash(u32 prev, const algo::strptr &str) {
 3031    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3032}
 3033
 3034// --- algo.LnumStr10_U64.ch.Init
 3035inline void algo::ch_Init(algo::LnumStr10_U64 &parent) {
 3036    for (int i = 0; i < 10; i++) {
 3037        parent.ch[i] = '0';
 3038    }
 3039}
 3040
 3041// --- algo.LnumStr10_U64.ch.Max
 3042// always return constant 10
 3043inline int algo::ch_Max(algo::LnumStr10_U64& parent) {
 3044    (void)parent;
 3045    return 10;
 3046}
 3047
 3048// --- algo.LnumStr10_U64.ch.N
 3049inline int algo::ch_N(const algo::LnumStr10_U64& parent) {
 3050    u64 ret;
 3051    ret = 0;
 3052    while (ret<10 && parent.ch[ret]==u8('0')) {
 3053        ret++;
 3054    }
 3055    ret = 10 - ret;
 3056    return int(ret);
 3057}
 3058
 3059// --- algo.LnumStr10_U64.ch.AssignStrptr
 3060// Copy from strptr (operator=)
 3061inline void algo::LnumStr10_U64::operator =(const algo::strptr &str) {
 3062    ch_SetStrptr(*this, str);
 3063}
 3064
 3065// --- algo.LnumStr10_U64.ch.Set
 3066// Copy from same type
 3067// Copy value from RHS.
 3068inline void algo::LnumStr10_U64::operator =(const algo::LnumStr10_U64& parent) {
 3069    memcpy(ch, parent.ch, 10);
 3070}
 3071
 3072// --- algo.LnumStr10_U64.ch.Ctor
 3073inline  algo::LnumStr10_U64::LnumStr10_U64(const algo::LnumStr10_U64 &rhs) {
 3074    operator =(rhs);
 3075}
 3076
 3077// --- algo.LnumStr10_U64.ch.CtorStrptr
 3078inline  algo::LnumStr10_U64::LnumStr10_U64(const algo::strptr &rhs) {
 3079    ch_SetStrptr(*this, rhs);
 3080}
 3081
 3082// --- algo.LnumStr10_U64.ch.Cast
 3083inline algo::LnumStr10_U64::operator algo::strptr () const {
 3084    return ch_Getary(*this);
 3085}
 3086
 3087// --- algo.LnumStr10_U64..Cmp
 3088inline i32 algo::LnumStr10_U64_Cmp(algo::LnumStr10_U64& lhs, algo::LnumStr10_U64& rhs) {
 3089    i32 retval = 0;
 3090    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3091    return retval;
 3092}
 3093
 3094// --- algo.LnumStr10_U64..Init
 3095// Set all fields to initial values.
 3096inline void algo::LnumStr10_U64_Init(algo::LnumStr10_U64& parent) {
 3097    for (int i = 0; i < 10; i++) {
 3098        parent.ch[i] = '0';
 3099    }
 3100}
 3101
 3102// --- algo.LnumStr10_U64..Eq
 3103inline bool algo::LnumStr10_U64_Eq(algo::LnumStr10_U64& lhs, algo::LnumStr10_U64& rhs) {
 3104    bool retval = true;
 3105    retval = retval
 3106    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3107    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
 3108    return retval;
 3109}
 3110
 3111// --- algo.LnumStr10_U64..EqStrptr
 3112inline bool algo::LnumStr10_U64_EqStrptr(const algo::LnumStr10_U64& lhs, const algo::strptr& rhs) {
 3113    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3114}
 3115
 3116inline bool algo::LnumStr11_U64::operator ==(const algo::LnumStr11_U64 &rhs) const {
 3117    return algo::LnumStr11_U64_Eq(const_cast<algo::LnumStr11_U64&>(*this),const_cast<algo::LnumStr11_U64&>(rhs));
 3118}
 3119
 3120inline bool algo::LnumStr11_U64::operator !=(const algo::LnumStr11_U64 &rhs) const {
 3121    return !algo::LnumStr11_U64_Eq(const_cast<algo::LnumStr11_U64&>(*this),const_cast<algo::LnumStr11_U64&>(rhs));
 3122}
 3123
 3124inline bool algo::LnumStr11_U64::operator ==(const algo::strptr &rhs) const {
 3125    return algo::LnumStr11_U64_EqStrptr(const_cast<algo::LnumStr11_U64&>(*this),rhs);
 3126}
 3127inline algo::LnumStr11_U64::LnumStr11_U64() {
 3128    algo::LnumStr11_U64_Init(*this);
 3129}
 3130
 3131
 3132// --- algo.LnumStr11_U64.ch.Getary
 3133// Access string as array of chars
 3134inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr11_U64& parent) {
 3135    int len = ch_N(parent);
 3136    algo::aryptr<char> ret((char*)parent.ch, len);
 3137    ret.elems += 11 - len;
 3138    return ret;
 3139}
 3140
 3141// --- algo.LnumStr11_U64.ch.HashStrptr
 3142inline u32 algo::LnumStr11_U64_Hash(u32 prev, const algo::strptr &str) {
 3143    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3144}
 3145
 3146// --- algo.LnumStr11_U64.ch.Init
 3147inline void algo::ch_Init(algo::LnumStr11_U64 &parent) {
 3148    for (int i = 0; i < 11; i++) {
 3149        parent.ch[i] = '0';
 3150    }
 3151}
 3152
 3153// --- algo.LnumStr11_U64.ch.Max
 3154// always return constant 11
 3155inline int algo::ch_Max(algo::LnumStr11_U64& parent) {
 3156    (void)parent;
 3157    return 11;
 3158}
 3159
 3160// --- algo.LnumStr11_U64.ch.N
 3161inline int algo::ch_N(const algo::LnumStr11_U64& parent) {
 3162    u64 ret;
 3163    ret = 0;
 3164    while (ret<11 && parent.ch[ret]==u8('0')) {
 3165        ret++;
 3166    }
 3167    ret = 11 - ret;
 3168    return int(ret);
 3169}
 3170
 3171// --- algo.LnumStr11_U64.ch.AssignStrptr
 3172// Copy from strptr (operator=)
 3173inline void algo::LnumStr11_U64::operator =(const algo::strptr &str) {
 3174    ch_SetStrptr(*this, str);
 3175}
 3176
 3177// --- algo.LnumStr11_U64.ch.Set
 3178// Copy from same type
 3179// Copy value from RHS.
 3180inline void algo::LnumStr11_U64::operator =(const algo::LnumStr11_U64& parent) {
 3181    memcpy(ch, parent.ch, 11);
 3182}
 3183
 3184// --- algo.LnumStr11_U64.ch.Ctor
 3185inline  algo::LnumStr11_U64::LnumStr11_U64(const algo::LnumStr11_U64 &rhs) {
 3186    operator =(rhs);
 3187}
 3188
 3189// --- algo.LnumStr11_U64.ch.CtorStrptr
 3190inline  algo::LnumStr11_U64::LnumStr11_U64(const algo::strptr &rhs) {
 3191    ch_SetStrptr(*this, rhs);
 3192}
 3193
 3194// --- algo.LnumStr11_U64.ch.Cast
 3195inline algo::LnumStr11_U64::operator algo::strptr () const {
 3196    return ch_Getary(*this);
 3197}
 3198
 3199// --- algo.LnumStr11_U64..Cmp
 3200inline i32 algo::LnumStr11_U64_Cmp(algo::LnumStr11_U64& lhs, algo::LnumStr11_U64& rhs) {
 3201    i32 retval = 0;
 3202    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3203    return retval;
 3204}
 3205
 3206// --- algo.LnumStr11_U64..Init
 3207// Set all fields to initial values.
 3208inline void algo::LnumStr11_U64_Init(algo::LnumStr11_U64& parent) {
 3209    for (int i = 0; i < 11; i++) {
 3210        parent.ch[i] = '0';
 3211    }
 3212}
 3213
 3214// --- algo.LnumStr11_U64..Eq
 3215inline bool algo::LnumStr11_U64_Eq(algo::LnumStr11_U64& lhs, algo::LnumStr11_U64& rhs) {
 3216    bool retval = true;
 3217    retval = retval
 3218    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3219    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8)
 3220    &&*(u8*)(lhs.ch+10) == *(u8*)(rhs.ch+10);
 3221    return retval;
 3222}
 3223
 3224// --- algo.LnumStr11_U64..EqStrptr
 3225inline bool algo::LnumStr11_U64_EqStrptr(const algo::LnumStr11_U64& lhs, const algo::strptr& rhs) {
 3226    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3227}
 3228
 3229inline bool algo::LnumStr12_U64::operator ==(const algo::LnumStr12_U64 &rhs) const {
 3230    return algo::LnumStr12_U64_Eq(const_cast<algo::LnumStr12_U64&>(*this),const_cast<algo::LnumStr12_U64&>(rhs));
 3231}
 3232
 3233inline bool algo::LnumStr12_U64::operator !=(const algo::LnumStr12_U64 &rhs) const {
 3234    return !algo::LnumStr12_U64_Eq(const_cast<algo::LnumStr12_U64&>(*this),const_cast<algo::LnumStr12_U64&>(rhs));
 3235}
 3236
 3237inline bool algo::LnumStr12_U64::operator ==(const algo::strptr &rhs) const {
 3238    return algo::LnumStr12_U64_EqStrptr(const_cast<algo::LnumStr12_U64&>(*this),rhs);
 3239}
 3240inline algo::LnumStr12_U64::LnumStr12_U64() {
 3241    algo::LnumStr12_U64_Init(*this);
 3242}
 3243
 3244
 3245// --- algo.LnumStr12_U64.ch.Getary
 3246// Access string as array of chars
 3247inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr12_U64& parent) {
 3248    int len = ch_N(parent);
 3249    algo::aryptr<char> ret((char*)parent.ch, len);
 3250    ret.elems += 12 - len;
 3251    return ret;
 3252}
 3253
 3254// --- algo.LnumStr12_U64.ch.HashStrptr
 3255inline u32 algo::LnumStr12_U64_Hash(u32 prev, const algo::strptr &str) {
 3256    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3257}
 3258
 3259// --- algo.LnumStr12_U64.ch.Init
 3260inline void algo::ch_Init(algo::LnumStr12_U64 &parent) {
 3261    for (int i = 0; i < 12; i++) {
 3262        parent.ch[i] = '0';
 3263    }
 3264}
 3265
 3266// --- algo.LnumStr12_U64.ch.Max
 3267// always return constant 12
 3268inline int algo::ch_Max(algo::LnumStr12_U64& parent) {
 3269    (void)parent;
 3270    return 12;
 3271}
 3272
 3273// --- algo.LnumStr12_U64.ch.N
 3274inline int algo::ch_N(const algo::LnumStr12_U64& parent) {
 3275    u64 ret;
 3276    ret = 0;
 3277    while (ret<12 && parent.ch[ret]==u8('0')) {
 3278        ret++;
 3279    }
 3280    ret = 12 - ret;
 3281    return int(ret);
 3282}
 3283
 3284// --- algo.LnumStr12_U64.ch.AssignStrptr
 3285// Copy from strptr (operator=)
 3286inline void algo::LnumStr12_U64::operator =(const algo::strptr &str) {
 3287    ch_SetStrptr(*this, str);
 3288}
 3289
 3290// --- algo.LnumStr12_U64.ch.Set
 3291// Copy from same type
 3292// Copy value from RHS.
 3293inline void algo::LnumStr12_U64::operator =(const algo::LnumStr12_U64& parent) {
 3294    memcpy(ch, parent.ch, 12);
 3295}
 3296
 3297// --- algo.LnumStr12_U64.ch.Ctor
 3298inline  algo::LnumStr12_U64::LnumStr12_U64(const algo::LnumStr12_U64 &rhs) {
 3299    operator =(rhs);
 3300}
 3301
 3302// --- algo.LnumStr12_U64.ch.CtorStrptr
 3303inline  algo::LnumStr12_U64::LnumStr12_U64(const algo::strptr &rhs) {
 3304    ch_SetStrptr(*this, rhs);
 3305}
 3306
 3307// --- algo.LnumStr12_U64.ch.Cast
 3308inline algo::LnumStr12_U64::operator algo::strptr () const {
 3309    return ch_Getary(*this);
 3310}
 3311
 3312// --- algo.LnumStr12_U64..Cmp
 3313inline i32 algo::LnumStr12_U64_Cmp(algo::LnumStr12_U64& lhs, algo::LnumStr12_U64& rhs) {
 3314    i32 retval = 0;
 3315    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3316    return retval;
 3317}
 3318
 3319// --- algo.LnumStr12_U64..Init
 3320// Set all fields to initial values.
 3321inline void algo::LnumStr12_U64_Init(algo::LnumStr12_U64& parent) {
 3322    for (int i = 0; i < 12; i++) {
 3323        parent.ch[i] = '0';
 3324    }
 3325}
 3326
 3327// --- algo.LnumStr12_U64..Eq
 3328inline bool algo::LnumStr12_U64_Eq(algo::LnumStr12_U64& lhs, algo::LnumStr12_U64& rhs) {
 3329    bool retval = true;
 3330    retval = retval
 3331    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3332    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
 3333    return retval;
 3334}
 3335
 3336// --- algo.LnumStr12_U64..EqStrptr
 3337inline bool algo::LnumStr12_U64_EqStrptr(const algo::LnumStr12_U64& lhs, const algo::strptr& rhs) {
 3338    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3339}
 3340
 3341inline bool algo::LnumStr13_U64_Base36::operator ==(const algo::LnumStr13_U64_Base36 &rhs) const {
 3342    return algo::LnumStr13_U64_Base36_Eq(const_cast<algo::LnumStr13_U64_Base36&>(*this),const_cast<algo::LnumStr13_U64_Base36&>(rhs));
 3343}
 3344
 3345inline bool algo::LnumStr13_U64_Base36::operator !=(const algo::LnumStr13_U64_Base36 &rhs) const {
 3346    return !algo::LnumStr13_U64_Base36_Eq(const_cast<algo::LnumStr13_U64_Base36&>(*this),const_cast<algo::LnumStr13_U64_Base36&>(rhs));
 3347}
 3348
 3349inline bool algo::LnumStr13_U64_Base36::operator ==(const algo::strptr &rhs) const {
 3350    return algo::LnumStr13_U64_Base36_EqStrptr(const_cast<algo::LnumStr13_U64_Base36&>(*this),rhs);
 3351}
 3352inline algo::LnumStr13_U64_Base36::LnumStr13_U64_Base36() {
 3353    algo::LnumStr13_U64_Base36_Init(*this);
 3354}
 3355
 3356
 3357// --- algo.LnumStr13_U64_Base36.ch.Getary
 3358// Access string as array of chars
 3359inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr13_U64_Base36& parent) {
 3360    int len = ch_N(parent);
 3361    algo::aryptr<char> ret((char*)parent.ch, len);
 3362    ret.elems += 13 - len;
 3363    return ret;
 3364}
 3365
 3366// --- algo.LnumStr13_U64_Base36.ch.HashStrptr
 3367inline u32 algo::LnumStr13_U64_Base36_Hash(u32 prev, const algo::strptr &str) {
 3368    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3369}
 3370
 3371// --- algo.LnumStr13_U64_Base36.ch.Init
 3372inline void algo::ch_Init(algo::LnumStr13_U64_Base36 &parent) {
 3373    for (int i = 0; i < 13; i++) {
 3374        parent.ch[i] = '0';
 3375    }
 3376}
 3377
 3378// --- algo.LnumStr13_U64_Base36.ch.Max
 3379// always return constant 13
 3380inline int algo::ch_Max(algo::LnumStr13_U64_Base36& parent) {
 3381    (void)parent;
 3382    return 13;
 3383}
 3384
 3385// --- algo.LnumStr13_U64_Base36.ch.N
 3386inline int algo::ch_N(const algo::LnumStr13_U64_Base36& parent) {
 3387    u64 ret;
 3388    ret = 0;
 3389    while (ret<13 && parent.ch[ret]==u8('0')) {
 3390        ret++;
 3391    }
 3392    ret = 13 - ret;
 3393    return int(ret);
 3394}
 3395
 3396// --- algo.LnumStr13_U64_Base36.ch.AssignStrptr
 3397// Copy from strptr (operator=)
 3398inline void algo::LnumStr13_U64_Base36::operator =(const algo::strptr &str) {
 3399    ch_SetStrptr(*this, str);
 3400}
 3401
 3402// --- algo.LnumStr13_U64_Base36.ch.Set
 3403// Copy from same type
 3404// Copy value from RHS.
 3405inline void algo::LnumStr13_U64_Base36::operator =(const algo::LnumStr13_U64_Base36& parent) {
 3406    memcpy(ch, parent.ch, 13);
 3407}
 3408
 3409// --- algo.LnumStr13_U64_Base36.ch.Ctor
 3410inline  algo::LnumStr13_U64_Base36::LnumStr13_U64_Base36(const algo::LnumStr13_U64_Base36 &rhs) {
 3411    operator =(rhs);
 3412}
 3413
 3414// --- algo.LnumStr13_U64_Base36.ch.CtorStrptr
 3415inline  algo::LnumStr13_U64_Base36::LnumStr13_U64_Base36(const algo::strptr &rhs) {
 3416    ch_SetStrptr(*this, rhs);
 3417}
 3418
 3419// --- algo.LnumStr13_U64_Base36.ch.Cast
 3420inline algo::LnumStr13_U64_Base36::operator algo::strptr () const {
 3421    return ch_Getary(*this);
 3422}
 3423
 3424// --- algo.LnumStr13_U64_Base36..Cmp
 3425inline i32 algo::LnumStr13_U64_Base36_Cmp(algo::LnumStr13_U64_Base36& lhs, algo::LnumStr13_U64_Base36& rhs) {
 3426    i32 retval = 0;
 3427    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3428    return retval;
 3429}
 3430
 3431// --- algo.LnumStr13_U64_Base36..Init
 3432// Set all fields to initial values.
 3433inline void algo::LnumStr13_U64_Base36_Init(algo::LnumStr13_U64_Base36& parent) {
 3434    for (int i = 0; i < 13; i++) {
 3435        parent.ch[i] = '0';
 3436    }
 3437}
 3438
 3439// --- algo.LnumStr13_U64_Base36..Eq
 3440inline bool algo::LnumStr13_U64_Base36_Eq(algo::LnumStr13_U64_Base36& lhs, algo::LnumStr13_U64_Base36& rhs) {
 3441    bool retval = true;
 3442    retval = retval
 3443    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3444    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
 3445    &&*(u8*)(lhs.ch+12) == *(u8*)(rhs.ch+12);
 3446    return retval;
 3447}
 3448
 3449// --- algo.LnumStr13_U64_Base36..EqStrptr
 3450inline bool algo::LnumStr13_U64_Base36_EqStrptr(const algo::LnumStr13_U64_Base36& lhs, const algo::strptr& rhs) {
 3451    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3452}
 3453
 3454inline bool algo::LnumStr16_U64_Base16::operator ==(const algo::LnumStr16_U64_Base16 &rhs) const {
 3455    return algo::LnumStr16_U64_Base16_Eq(const_cast<algo::LnumStr16_U64_Base16&>(*this),const_cast<algo::LnumStr16_U64_Base16&>(rhs));
 3456}
 3457
 3458inline bool algo::LnumStr16_U64_Base16::operator !=(const algo::LnumStr16_U64_Base16 &rhs) const {
 3459    return !algo::LnumStr16_U64_Base16_Eq(const_cast<algo::LnumStr16_U64_Base16&>(*this),const_cast<algo::LnumStr16_U64_Base16&>(rhs));
 3460}
 3461
 3462inline bool algo::LnumStr16_U64_Base16::operator ==(const algo::strptr &rhs) const {
 3463    return algo::LnumStr16_U64_Base16_EqStrptr(const_cast<algo::LnumStr16_U64_Base16&>(*this),rhs);
 3464}
 3465inline algo::LnumStr16_U64_Base16::LnumStr16_U64_Base16() {
 3466    algo::LnumStr16_U64_Base16_Init(*this);
 3467}
 3468
 3469
 3470// --- algo.LnumStr16_U64_Base16.ch.Getary
 3471// Access string as array of chars
 3472inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr16_U64_Base16& parent) {
 3473    int len = ch_N(parent);
 3474    algo::aryptr<char> ret((char*)parent.ch, len);
 3475    ret.elems += 16 - len;
 3476    return ret;
 3477}
 3478
 3479// --- algo.LnumStr16_U64_Base16.ch.HashStrptr
 3480inline u32 algo::LnumStr16_U64_Base16_Hash(u32 prev, const algo::strptr &str) {
 3481    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3482}
 3483
 3484// --- algo.LnumStr16_U64_Base16.ch.Init
 3485inline void algo::ch_Init(algo::LnumStr16_U64_Base16 &parent) {
 3486    for (int i = 0; i < 16; i++) {
 3487        parent.ch[i] = '0';
 3488    }
 3489}
 3490
 3491// --- algo.LnumStr16_U64_Base16.ch.Max
 3492// always return constant 16
 3493inline int algo::ch_Max(algo::LnumStr16_U64_Base16& parent) {
 3494    (void)parent;
 3495    return 16;
 3496}
 3497
 3498// --- algo.LnumStr16_U64_Base16.ch.N
 3499inline int algo::ch_N(const algo::LnumStr16_U64_Base16& parent) {
 3500    u64 ret;
 3501    ret = 0;
 3502    while (ret<16 && parent.ch[ret]==u8('0')) {
 3503        ret++;
 3504    }
 3505    ret = 16 - ret;
 3506    return int(ret);
 3507}
 3508
 3509// --- algo.LnumStr16_U64_Base16.ch.AssignStrptr
 3510// Copy from strptr (operator=)
 3511inline void algo::LnumStr16_U64_Base16::operator =(const algo::strptr &str) {
 3512    ch_SetStrptr(*this, str);
 3513}
 3514
 3515// --- algo.LnumStr16_U64_Base16.ch.Set
 3516// Copy from same type
 3517// Copy value from RHS.
 3518inline void algo::LnumStr16_U64_Base16::operator =(const algo::LnumStr16_U64_Base16& parent) {
 3519    memcpy(ch, parent.ch, 16);
 3520}
 3521
 3522// --- algo.LnumStr16_U64_Base16.ch.Ctor
 3523inline  algo::LnumStr16_U64_Base16::LnumStr16_U64_Base16(const algo::LnumStr16_U64_Base16 &rhs) {
 3524    operator =(rhs);
 3525}
 3526
 3527// --- algo.LnumStr16_U64_Base16.ch.CtorStrptr
 3528inline  algo::LnumStr16_U64_Base16::LnumStr16_U64_Base16(const algo::strptr &rhs) {
 3529    ch_SetStrptr(*this, rhs);
 3530}
 3531
 3532// --- algo.LnumStr16_U64_Base16.ch.Cast
 3533inline algo::LnumStr16_U64_Base16::operator algo::strptr () const {
 3534    return ch_Getary(*this);
 3535}
 3536
 3537// --- algo.LnumStr16_U64_Base16..Cmp
 3538inline i32 algo::LnumStr16_U64_Base16_Cmp(algo::LnumStr16_U64_Base16& lhs, algo::LnumStr16_U64_Base16& rhs) {
 3539    i32 retval = 0;
 3540    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3541    return retval;
 3542}
 3543
 3544// --- algo.LnumStr16_U64_Base16..Init
 3545// Set all fields to initial values.
 3546inline void algo::LnumStr16_U64_Base16_Init(algo::LnumStr16_U64_Base16& parent) {
 3547    for (int i = 0; i < 16; i++) {
 3548        parent.ch[i] = '0';
 3549    }
 3550}
 3551
 3552// --- algo.LnumStr16_U64_Base16..Eq
 3553inline bool algo::LnumStr16_U64_Base16_Eq(algo::LnumStr16_U64_Base16& lhs, algo::LnumStr16_U64_Base16& rhs) {
 3554    bool retval = true;
 3555    retval = retval
 3556    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3557    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8);
 3558    return retval;
 3559}
 3560
 3561// --- algo.LnumStr16_U64_Base16..EqStrptr
 3562inline bool algo::LnumStr16_U64_Base16_EqStrptr(const algo::LnumStr16_U64_Base16& lhs, const algo::strptr& rhs) {
 3563    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3564}
 3565
 3566inline bool algo::LnumStr1_U32::operator ==(const algo::LnumStr1_U32 &rhs) const {
 3567    return algo::LnumStr1_U32_Eq(const_cast<algo::LnumStr1_U32&>(*this),const_cast<algo::LnumStr1_U32&>(rhs));
 3568}
 3569
 3570inline bool algo::LnumStr1_U32::operator !=(const algo::LnumStr1_U32 &rhs) const {
 3571    return !algo::LnumStr1_U32_Eq(const_cast<algo::LnumStr1_U32&>(*this),const_cast<algo::LnumStr1_U32&>(rhs));
 3572}
 3573
 3574inline bool algo::LnumStr1_U32::operator ==(const algo::strptr &rhs) const {
 3575    return algo::LnumStr1_U32_EqStrptr(const_cast<algo::LnumStr1_U32&>(*this),rhs);
 3576}
 3577inline algo::LnumStr1_U32::LnumStr1_U32() {
 3578    algo::LnumStr1_U32_Init(*this);
 3579}
 3580
 3581
 3582// --- algo.LnumStr1_U32.ch.Getary
 3583// Access string as array of chars
 3584inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr1_U32& parent) {
 3585    int len = ch_N(parent);
 3586    algo::aryptr<char> ret((char*)parent.ch, len);
 3587    ret.elems += 1 - len;
 3588    return ret;
 3589}
 3590
 3591// --- algo.LnumStr1_U32.ch.HashStrptr
 3592inline u32 algo::LnumStr1_U32_Hash(u32 prev, const algo::strptr &str) {
 3593    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3594}
 3595
 3596// --- algo.LnumStr1_U32.ch.Init
 3597inline void algo::ch_Init(algo::LnumStr1_U32 &parent) {
 3598    for (int i = 0; i < 1; i++) {
 3599        parent.ch[i] = '0';
 3600    }
 3601}
 3602
 3603// --- algo.LnumStr1_U32.ch.Max
 3604// always return constant 1
 3605inline int algo::ch_Max(algo::LnumStr1_U32& parent) {
 3606    (void)parent;
 3607    return 1;
 3608}
 3609
 3610// --- algo.LnumStr1_U32.ch.N
 3611inline int algo::ch_N(const algo::LnumStr1_U32& parent) {
 3612    u64 ret;
 3613    ret = 0;
 3614    while (ret<1 && parent.ch[ret]==u8('0')) {
 3615        ret++;
 3616    }
 3617    ret = 1 - ret;
 3618    return int(ret);
 3619}
 3620
 3621// --- algo.LnumStr1_U32.ch.AssignStrptr
 3622// Copy from strptr (operator=)
 3623inline void algo::LnumStr1_U32::operator =(const algo::strptr &str) {
 3624    ch_SetStrptr(*this, str);
 3625}
 3626
 3627// --- algo.LnumStr1_U32.ch.Set
 3628// Copy from same type
 3629// Copy value from RHS.
 3630inline void algo::LnumStr1_U32::operator =(const algo::LnumStr1_U32& parent) {
 3631    memcpy(ch, parent.ch, 1);
 3632}
 3633
 3634// --- algo.LnumStr1_U32.ch.Ctor
 3635inline  algo::LnumStr1_U32::LnumStr1_U32(const algo::LnumStr1_U32 &rhs) {
 3636    operator =(rhs);
 3637}
 3638
 3639// --- algo.LnumStr1_U32.ch.CtorStrptr
 3640inline  algo::LnumStr1_U32::LnumStr1_U32(const algo::strptr &rhs) {
 3641    ch_SetStrptr(*this, rhs);
 3642}
 3643
 3644// --- algo.LnumStr1_U32.ch.Cast
 3645inline algo::LnumStr1_U32::operator algo::strptr () const {
 3646    return ch_Getary(*this);
 3647}
 3648
 3649// --- algo.LnumStr1_U32..Cmp
 3650inline i32 algo::LnumStr1_U32_Cmp(algo::LnumStr1_U32& lhs, algo::LnumStr1_U32& rhs) {
 3651    i32 retval = 0;
 3652    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3653    return retval;
 3654}
 3655
 3656// --- algo.LnumStr1_U32..Init
 3657// Set all fields to initial values.
 3658inline void algo::LnumStr1_U32_Init(algo::LnumStr1_U32& parent) {
 3659    for (int i = 0; i < 1; i++) {
 3660        parent.ch[i] = '0';
 3661    }
 3662}
 3663
 3664// --- algo.LnumStr1_U32..Eq
 3665inline bool algo::LnumStr1_U32_Eq(algo::LnumStr1_U32& lhs, algo::LnumStr1_U32& rhs) {
 3666    bool retval = true;
 3667    retval = retval
 3668    &&*(u8*)(lhs.ch+0) == *(u8*)(rhs.ch+0);
 3669    return retval;
 3670}
 3671
 3672// --- algo.LnumStr1_U32..EqStrptr
 3673inline bool algo::LnumStr1_U32_EqStrptr(const algo::LnumStr1_U32& lhs, const algo::strptr& rhs) {
 3674    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3675}
 3676
 3677inline bool algo::LnumStr20_U64::operator ==(const algo::LnumStr20_U64 &rhs) const {
 3678    return algo::LnumStr20_U64_Eq(const_cast<algo::LnumStr20_U64&>(*this),const_cast<algo::LnumStr20_U64&>(rhs));
 3679}
 3680
 3681inline bool algo::LnumStr20_U64::operator !=(const algo::LnumStr20_U64 &rhs) const {
 3682    return !algo::LnumStr20_U64_Eq(const_cast<algo::LnumStr20_U64&>(*this),const_cast<algo::LnumStr20_U64&>(rhs));
 3683}
 3684
 3685inline bool algo::LnumStr20_U64::operator ==(const algo::strptr &rhs) const {
 3686    return algo::LnumStr20_U64_EqStrptr(const_cast<algo::LnumStr20_U64&>(*this),rhs);
 3687}
 3688inline algo::LnumStr20_U64::LnumStr20_U64() {
 3689    algo::LnumStr20_U64_Init(*this);
 3690}
 3691
 3692
 3693// --- algo.LnumStr20_U64.ch.Getary
 3694// Access string as array of chars
 3695inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr20_U64& parent) {
 3696    int len = ch_N(parent);
 3697    algo::aryptr<char> ret((char*)parent.ch, len);
 3698    ret.elems += 20 - len;
 3699    return ret;
 3700}
 3701
 3702// --- algo.LnumStr20_U64.ch.HashStrptr
 3703inline u32 algo::LnumStr20_U64_Hash(u32 prev, const algo::strptr &str) {
 3704    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3705}
 3706
 3707// --- algo.LnumStr20_U64.ch.Init
 3708inline void algo::ch_Init(algo::LnumStr20_U64 &parent) {
 3709    for (int i = 0; i < 20; i++) {
 3710        parent.ch[i] = '0';
 3711    }
 3712}
 3713
 3714// --- algo.LnumStr20_U64.ch.Max
 3715// always return constant 20
 3716inline int algo::ch_Max(algo::LnumStr20_U64& parent) {
 3717    (void)parent;
 3718    return 20;
 3719}
 3720
 3721// --- algo.LnumStr20_U64.ch.N
 3722inline int algo::ch_N(const algo::LnumStr20_U64& parent) {
 3723    u64 ret;
 3724    ret = 0;
 3725    while (ret<20 && parent.ch[ret]==u8('0')) {
 3726        ret++;
 3727    }
 3728    ret = 20 - ret;
 3729    return int(ret);
 3730}
 3731
 3732// --- algo.LnumStr20_U64.ch.AssignStrptr
 3733// Copy from strptr (operator=)
 3734inline void algo::LnumStr20_U64::operator =(const algo::strptr &str) {
 3735    ch_SetStrptr(*this, str);
 3736}
 3737
 3738// --- algo.LnumStr20_U64.ch.Set
 3739// Copy from same type
 3740// Copy value from RHS.
 3741inline void algo::LnumStr20_U64::operator =(const algo::LnumStr20_U64& parent) {
 3742    memcpy(ch, parent.ch, 20);
 3743}
 3744
 3745// --- algo.LnumStr20_U64.ch.Ctor
 3746inline  algo::LnumStr20_U64::LnumStr20_U64(const algo::LnumStr20_U64 &rhs) {
 3747    operator =(rhs);
 3748}
 3749
 3750// --- algo.LnumStr20_U64.ch.CtorStrptr
 3751inline  algo::LnumStr20_U64::LnumStr20_U64(const algo::strptr &rhs) {
 3752    ch_SetStrptr(*this, rhs);
 3753}
 3754
 3755// --- algo.LnumStr20_U64.ch.Cast
 3756inline algo::LnumStr20_U64::operator algo::strptr () const {
 3757    return ch_Getary(*this);
 3758}
 3759
 3760// --- algo.LnumStr20_U64..Cmp
 3761inline i32 algo::LnumStr20_U64_Cmp(algo::LnumStr20_U64& lhs, algo::LnumStr20_U64& rhs) {
 3762    i32 retval = 0;
 3763    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3764    return retval;
 3765}
 3766
 3767// --- algo.LnumStr20_U64..Init
 3768// Set all fields to initial values.
 3769inline void algo::LnumStr20_U64_Init(algo::LnumStr20_U64& parent) {
 3770    for (int i = 0; i < 20; i++) {
 3771        parent.ch[i] = '0';
 3772    }
 3773}
 3774
 3775// --- algo.LnumStr20_U64..Eq
 3776inline bool algo::LnumStr20_U64_Eq(algo::LnumStr20_U64& lhs, algo::LnumStr20_U64& rhs) {
 3777    bool retval = true;
 3778    retval = retval
 3779    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3780    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 3781    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
 3782    return retval;
 3783}
 3784
 3785// --- algo.LnumStr20_U64..EqStrptr
 3786inline bool algo::LnumStr20_U64_EqStrptr(const algo::LnumStr20_U64& lhs, const algo::strptr& rhs) {
 3787    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3788}
 3789
 3790inline bool algo::LnumStr22_U64::operator ==(const algo::LnumStr22_U64 &rhs) const {
 3791    return algo::LnumStr22_U64_Eq(const_cast<algo::LnumStr22_U64&>(*this),const_cast<algo::LnumStr22_U64&>(rhs));
 3792}
 3793
 3794inline bool algo::LnumStr22_U64::operator !=(const algo::LnumStr22_U64 &rhs) const {
 3795    return !algo::LnumStr22_U64_Eq(const_cast<algo::LnumStr22_U64&>(*this),const_cast<algo::LnumStr22_U64&>(rhs));
 3796}
 3797
 3798inline bool algo::LnumStr22_U64::operator ==(const algo::strptr &rhs) const {
 3799    return algo::LnumStr22_U64_EqStrptr(const_cast<algo::LnumStr22_U64&>(*this),rhs);
 3800}
 3801inline algo::LnumStr22_U64::LnumStr22_U64() {
 3802    algo::LnumStr22_U64_Init(*this);
 3803}
 3804
 3805
 3806// --- algo.LnumStr22_U64.ch.Getary
 3807// Access string as array of chars
 3808inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr22_U64& parent) {
 3809    int len = ch_N(parent);
 3810    algo::aryptr<char> ret((char*)parent.ch, len);
 3811    ret.elems += 22 - len;
 3812    return ret;
 3813}
 3814
 3815// --- algo.LnumStr22_U64.ch.HashStrptr
 3816inline u32 algo::LnumStr22_U64_Hash(u32 prev, const algo::strptr &str) {
 3817    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3818}
 3819
 3820// --- algo.LnumStr22_U64.ch.Init
 3821inline void algo::ch_Init(algo::LnumStr22_U64 &parent) {
 3822    for (int i = 0; i < 22; i++) {
 3823        parent.ch[i] = '0';
 3824    }
 3825}
 3826
 3827// --- algo.LnumStr22_U64.ch.Max
 3828// always return constant 22
 3829inline int algo::ch_Max(algo::LnumStr22_U64& parent) {
 3830    (void)parent;
 3831    return 22;
 3832}
 3833
 3834// --- algo.LnumStr22_U64.ch.N
 3835inline int algo::ch_N(const algo::LnumStr22_U64& parent) {
 3836    u64 ret;
 3837    ret = 0;
 3838    while (ret<22 && parent.ch[ret]==u8('0')) {
 3839        ret++;
 3840    }
 3841    ret = 22 - ret;
 3842    return int(ret);
 3843}
 3844
 3845// --- algo.LnumStr22_U64.ch.AssignStrptr
 3846// Copy from strptr (operator=)
 3847inline void algo::LnumStr22_U64::operator =(const algo::strptr &str) {
 3848    ch_SetStrptr(*this, str);
 3849}
 3850
 3851// --- algo.LnumStr22_U64.ch.Set
 3852// Copy from same type
 3853// Copy value from RHS.
 3854inline void algo::LnumStr22_U64::operator =(const algo::LnumStr22_U64& parent) {
 3855    memcpy(ch, parent.ch, 22);
 3856}
 3857
 3858// --- algo.LnumStr22_U64.ch.Ctor
 3859inline  algo::LnumStr22_U64::LnumStr22_U64(const algo::LnumStr22_U64 &rhs) {
 3860    operator =(rhs);
 3861}
 3862
 3863// --- algo.LnumStr22_U64.ch.CtorStrptr
 3864inline  algo::LnumStr22_U64::LnumStr22_U64(const algo::strptr &rhs) {
 3865    ch_SetStrptr(*this, rhs);
 3866}
 3867
 3868// --- algo.LnumStr22_U64.ch.Cast
 3869inline algo::LnumStr22_U64::operator algo::strptr () const {
 3870    return ch_Getary(*this);
 3871}
 3872
 3873// --- algo.LnumStr22_U64..Cmp
 3874inline i32 algo::LnumStr22_U64_Cmp(algo::LnumStr22_U64& lhs, algo::LnumStr22_U64& rhs) {
 3875    i32 retval = 0;
 3876    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3877    return retval;
 3878}
 3879
 3880// --- algo.LnumStr22_U64..Init
 3881// Set all fields to initial values.
 3882inline void algo::LnumStr22_U64_Init(algo::LnumStr22_U64& parent) {
 3883    for (int i = 0; i < 22; i++) {
 3884        parent.ch[i] = '0';
 3885    }
 3886}
 3887
 3888// --- algo.LnumStr22_U64..Eq
 3889inline bool algo::LnumStr22_U64_Eq(algo::LnumStr22_U64& lhs, algo::LnumStr22_U64& rhs) {
 3890    bool retval = true;
 3891    retval = retval
 3892    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 3893    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 3894    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16)
 3895    &&*(u16*)(lhs.ch+20) == *(u16*)(rhs.ch+20);
 3896    return retval;
 3897}
 3898
 3899// --- algo.LnumStr22_U64..EqStrptr
 3900inline bool algo::LnumStr22_U64_EqStrptr(const algo::LnumStr22_U64& lhs, const algo::strptr& rhs) {
 3901    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 3902}
 3903
 3904inline bool algo::LnumStr2_U32::operator ==(const algo::LnumStr2_U32 &rhs) const {
 3905    return algo::LnumStr2_U32_Eq(const_cast<algo::LnumStr2_U32&>(*this),const_cast<algo::LnumStr2_U32&>(rhs));
 3906}
 3907
 3908inline bool algo::LnumStr2_U32::operator !=(const algo::LnumStr2_U32 &rhs) const {
 3909    return !algo::LnumStr2_U32_Eq(const_cast<algo::LnumStr2_U32&>(*this),const_cast<algo::LnumStr2_U32&>(rhs));
 3910}
 3911
 3912inline bool algo::LnumStr2_U32::operator ==(const algo::strptr &rhs) const {
 3913    return algo::LnumStr2_U32_EqStrptr(const_cast<algo::LnumStr2_U32&>(*this),rhs);
 3914}
 3915inline algo::LnumStr2_U32::LnumStr2_U32() {
 3916    algo::LnumStr2_U32_Init(*this);
 3917}
 3918
 3919
 3920// --- algo.LnumStr2_U32.ch.Getary
 3921// Access string as array of chars
 3922inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr2_U32& parent) {
 3923    int len = ch_N(parent);
 3924    algo::aryptr<char> ret((char*)parent.ch, len);
 3925    ret.elems += 2 - len;
 3926    return ret;
 3927}
 3928
 3929// --- algo.LnumStr2_U32.ch.HashStrptr
 3930inline u32 algo::LnumStr2_U32_Hash(u32 prev, const algo::strptr &str) {
 3931    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 3932}
 3933
 3934// --- algo.LnumStr2_U32.ch.Init
 3935inline void algo::ch_Init(algo::LnumStr2_U32 &parent) {
 3936    for (int i = 0; i < 2; i++) {
 3937        parent.ch[i] = '0';
 3938    }
 3939}
 3940
 3941// --- algo.LnumStr2_U32.ch.Max
 3942// always return constant 2
 3943inline int algo::ch_Max(algo::LnumStr2_U32& parent) {
 3944    (void)parent;
 3945    return 2;
 3946}
 3947
 3948// --- algo.LnumStr2_U32.ch.N
 3949inline int algo::ch_N(const algo::LnumStr2_U32& parent) {
 3950    u64 ret;
 3951    ret = 0;
 3952    while (ret<2 && parent.ch[ret]==u8('0')) {
 3953        ret++;
 3954    }
 3955    ret = 2 - ret;
 3956    return int(ret);
 3957}
 3958
 3959// --- algo.LnumStr2_U32.ch.AssignStrptr
 3960// Copy from strptr (operator=)
 3961inline void algo::LnumStr2_U32::operator =(const algo::strptr &str) {
 3962    ch_SetStrptr(*this, str);
 3963}
 3964
 3965// --- algo.LnumStr2_U32.ch.Set
 3966// Copy from same type
 3967// Copy value from RHS.
 3968inline void algo::LnumStr2_U32::operator =(const algo::LnumStr2_U32& parent) {
 3969    memcpy(ch, parent.ch, 2);
 3970}
 3971
 3972// --- algo.LnumStr2_U32.ch.Ctor
 3973inline  algo::LnumStr2_U32::LnumStr2_U32(const algo::LnumStr2_U32 &rhs) {
 3974    operator =(rhs);
 3975}
 3976
 3977// --- algo.LnumStr2_U32.ch.CtorStrptr
 3978inline  algo::LnumStr2_U32::LnumStr2_U32(const algo::strptr &rhs) {
 3979    ch_SetStrptr(*this, rhs);
 3980}
 3981
 3982// --- algo.LnumStr2_U32.ch.Cast
 3983inline algo::LnumStr2_U32::operator algo::strptr () const {
 3984    return ch_Getary(*this);
 3985}
 3986
 3987// --- algo.LnumStr2_U32..Cmp
 3988inline i32 algo::LnumStr2_U32_Cmp(algo::LnumStr2_U32& lhs, algo::LnumStr2_U32& rhs) {
 3989    i32 retval = 0;
 3990    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 3991    return retval;
 3992}
 3993
 3994// --- algo.LnumStr2_U32..Init
 3995// Set all fields to initial values.
 3996inline void algo::LnumStr2_U32_Init(algo::LnumStr2_U32& parent) {
 3997    for (int i = 0; i < 2; i++) {
 3998        parent.ch[i] = '0';
 3999    }
 4000}
 4001
 4002// --- algo.LnumStr2_U32..Eq
 4003inline bool algo::LnumStr2_U32_Eq(algo::LnumStr2_U32& lhs, algo::LnumStr2_U32& rhs) {
 4004    bool retval = true;
 4005    retval = retval
 4006    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0);
 4007    return retval;
 4008}
 4009
 4010// --- algo.LnumStr2_U32..EqStrptr
 4011inline bool algo::LnumStr2_U32_EqStrptr(const algo::LnumStr2_U32& lhs, const algo::strptr& rhs) {
 4012    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4013}
 4014
 4015inline bool algo::LnumStr3_U32::operator ==(const algo::LnumStr3_U32 &rhs) const {
 4016    return algo::LnumStr3_U32_Eq(const_cast<algo::LnumStr3_U32&>(*this),const_cast<algo::LnumStr3_U32&>(rhs));
 4017}
 4018
 4019inline bool algo::LnumStr3_U32::operator !=(const algo::LnumStr3_U32 &rhs) const {
 4020    return !algo::LnumStr3_U32_Eq(const_cast<algo::LnumStr3_U32&>(*this),const_cast<algo::LnumStr3_U32&>(rhs));
 4021}
 4022
 4023inline bool algo::LnumStr3_U32::operator ==(const algo::strptr &rhs) const {
 4024    return algo::LnumStr3_U32_EqStrptr(const_cast<algo::LnumStr3_U32&>(*this),rhs);
 4025}
 4026inline algo::LnumStr3_U32::LnumStr3_U32() {
 4027    algo::LnumStr3_U32_Init(*this);
 4028}
 4029
 4030
 4031// --- algo.LnumStr3_U32.ch.Getary
 4032// Access string as array of chars
 4033inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr3_U32& parent) {
 4034    int len = ch_N(parent);
 4035    algo::aryptr<char> ret((char*)parent.ch, len);
 4036    ret.elems += 3 - len;
 4037    return ret;
 4038}
 4039
 4040// --- algo.LnumStr3_U32.ch.HashStrptr
 4041inline u32 algo::LnumStr3_U32_Hash(u32 prev, const algo::strptr &str) {
 4042    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4043}
 4044
 4045// --- algo.LnumStr3_U32.ch.Init
 4046inline void algo::ch_Init(algo::LnumStr3_U32 &parent) {
 4047    for (int i = 0; i < 3; i++) {
 4048        parent.ch[i] = '0';
 4049    }
 4050}
 4051
 4052// --- algo.LnumStr3_U32.ch.Max
 4053// always return constant 3
 4054inline int algo::ch_Max(algo::LnumStr3_U32& parent) {
 4055    (void)parent;
 4056    return 3;
 4057}
 4058
 4059// --- algo.LnumStr3_U32.ch.N
 4060inline int algo::ch_N(const algo::LnumStr3_U32& parent) {
 4061    u64 ret;
 4062    ret = 0;
 4063    while (ret<3 && parent.ch[ret]==u8('0')) {
 4064        ret++;
 4065    }
 4066    ret = 3 - ret;
 4067    return int(ret);
 4068}
 4069
 4070// --- algo.LnumStr3_U32.ch.AssignStrptr
 4071// Copy from strptr (operator=)
 4072inline void algo::LnumStr3_U32::operator =(const algo::strptr &str) {
 4073    ch_SetStrptr(*this, str);
 4074}
 4075
 4076// --- algo.LnumStr3_U32.ch.Set
 4077// Copy from same type
 4078// Copy value from RHS.
 4079inline void algo::LnumStr3_U32::operator =(const algo::LnumStr3_U32& parent) {
 4080    memcpy(ch, parent.ch, 3);
 4081}
 4082
 4083// --- algo.LnumStr3_U32.ch.Ctor
 4084inline  algo::LnumStr3_U32::LnumStr3_U32(const algo::LnumStr3_U32 &rhs) {
 4085    operator =(rhs);
 4086}
 4087
 4088// --- algo.LnumStr3_U32.ch.CtorStrptr
 4089inline  algo::LnumStr3_U32::LnumStr3_U32(const algo::strptr &rhs) {
 4090    ch_SetStrptr(*this, rhs);
 4091}
 4092
 4093// --- algo.LnumStr3_U32.ch.Cast
 4094inline algo::LnumStr3_U32::operator algo::strptr () const {
 4095    return ch_Getary(*this);
 4096}
 4097
 4098// --- algo.LnumStr3_U32..Cmp
 4099inline i32 algo::LnumStr3_U32_Cmp(algo::LnumStr3_U32& lhs, algo::LnumStr3_U32& rhs) {
 4100    i32 retval = 0;
 4101    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4102    return retval;
 4103}
 4104
 4105// --- algo.LnumStr3_U32..Init
 4106// Set all fields to initial values.
 4107inline void algo::LnumStr3_U32_Init(algo::LnumStr3_U32& parent) {
 4108    for (int i = 0; i < 3; i++) {
 4109        parent.ch[i] = '0';
 4110    }
 4111}
 4112
 4113// --- algo.LnumStr3_U32..Eq
 4114inline bool algo::LnumStr3_U32_Eq(algo::LnumStr3_U32& lhs, algo::LnumStr3_U32& rhs) {
 4115    bool retval = true;
 4116    retval = retval
 4117    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
 4118    &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
 4119    return retval;
 4120}
 4121
 4122// --- algo.LnumStr3_U32..EqStrptr
 4123inline bool algo::LnumStr3_U32_EqStrptr(const algo::LnumStr3_U32& lhs, const algo::strptr& rhs) {
 4124    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4125}
 4126
 4127inline bool algo::LnumStr4_U32::operator ==(const algo::LnumStr4_U32 &rhs) const {
 4128    return algo::LnumStr4_U32_Eq(const_cast<algo::LnumStr4_U32&>(*this),const_cast<algo::LnumStr4_U32&>(rhs));
 4129}
 4130
 4131inline bool algo::LnumStr4_U32::operator !=(const algo::LnumStr4_U32 &rhs) const {
 4132    return !algo::LnumStr4_U32_Eq(const_cast<algo::LnumStr4_U32&>(*this),const_cast<algo::LnumStr4_U32&>(rhs));
 4133}
 4134
 4135inline bool algo::LnumStr4_U32::operator ==(const algo::strptr &rhs) const {
 4136    return algo::LnumStr4_U32_EqStrptr(const_cast<algo::LnumStr4_U32&>(*this),rhs);
 4137}
 4138inline algo::LnumStr4_U32::LnumStr4_U32() {
 4139    algo::LnumStr4_U32_Init(*this);
 4140}
 4141
 4142
 4143// --- algo.LnumStr4_U32.ch.Getary
 4144// Access string as array of chars
 4145inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr4_U32& parent) {
 4146    int len = ch_N(parent);
 4147    algo::aryptr<char> ret((char*)parent.ch, len);
 4148    ret.elems += 4 - len;
 4149    return ret;
 4150}
 4151
 4152// --- algo.LnumStr4_U32.ch.HashStrptr
 4153inline u32 algo::LnumStr4_U32_Hash(u32 prev, const algo::strptr &str) {
 4154    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4155}
 4156
 4157// --- algo.LnumStr4_U32.ch.Init
 4158inline void algo::ch_Init(algo::LnumStr4_U32 &parent) {
 4159    for (int i = 0; i < 4; i++) {
 4160        parent.ch[i] = '0';
 4161    }
 4162}
 4163
 4164// --- algo.LnumStr4_U32.ch.Max
 4165// always return constant 4
 4166inline int algo::ch_Max(algo::LnumStr4_U32& parent) {
 4167    (void)parent;
 4168    return 4;
 4169}
 4170
 4171// --- algo.LnumStr4_U32.ch.N
 4172inline int algo::ch_N(const algo::LnumStr4_U32& parent) {
 4173    u64 ret;
 4174    ret = 0;
 4175    while (ret<4 && parent.ch[ret]==u8('0')) {
 4176        ret++;
 4177    }
 4178    ret = 4 - ret;
 4179    return int(ret);
 4180}
 4181
 4182// --- algo.LnumStr4_U32.ch.AssignStrptr
 4183// Copy from strptr (operator=)
 4184inline void algo::LnumStr4_U32::operator =(const algo::strptr &str) {
 4185    ch_SetStrptr(*this, str);
 4186}
 4187
 4188// --- algo.LnumStr4_U32.ch.Set
 4189// Copy from same type
 4190// Copy value from RHS.
 4191inline void algo::LnumStr4_U32::operator =(const algo::LnumStr4_U32& parent) {
 4192    memcpy(ch, parent.ch, 4);
 4193}
 4194
 4195// --- algo.LnumStr4_U32.ch.Ctor
 4196inline  algo::LnumStr4_U32::LnumStr4_U32(const algo::LnumStr4_U32 &rhs) {
 4197    operator =(rhs);
 4198}
 4199
 4200// --- algo.LnumStr4_U32.ch.CtorStrptr
 4201inline  algo::LnumStr4_U32::LnumStr4_U32(const algo::strptr &rhs) {
 4202    ch_SetStrptr(*this, rhs);
 4203}
 4204
 4205// --- algo.LnumStr4_U32.ch.Cast
 4206inline algo::LnumStr4_U32::operator algo::strptr () const {
 4207    return ch_Getary(*this);
 4208}
 4209
 4210// --- algo.LnumStr4_U32..Cmp
 4211inline i32 algo::LnumStr4_U32_Cmp(algo::LnumStr4_U32& lhs, algo::LnumStr4_U32& rhs) {
 4212    i32 retval = 0;
 4213    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4214    return retval;
 4215}
 4216
 4217// --- algo.LnumStr4_U32..Init
 4218// Set all fields to initial values.
 4219inline void algo::LnumStr4_U32_Init(algo::LnumStr4_U32& parent) {
 4220    for (int i = 0; i < 4; i++) {
 4221        parent.ch[i] = '0';
 4222    }
 4223}
 4224
 4225// --- algo.LnumStr4_U32..Eq
 4226inline bool algo::LnumStr4_U32_Eq(algo::LnumStr4_U32& lhs, algo::LnumStr4_U32& rhs) {
 4227    bool retval = true;
 4228    retval = retval
 4229    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
 4230    return retval;
 4231}
 4232
 4233// --- algo.LnumStr4_U32..EqStrptr
 4234inline bool algo::LnumStr4_U32_EqStrptr(const algo::LnumStr4_U32& lhs, const algo::strptr& rhs) {
 4235    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4236}
 4237
 4238inline bool algo::LnumStr5_U32::operator ==(const algo::LnumStr5_U32 &rhs) const {
 4239    return algo::LnumStr5_U32_Eq(const_cast<algo::LnumStr5_U32&>(*this),const_cast<algo::LnumStr5_U32&>(rhs));
 4240}
 4241
 4242inline bool algo::LnumStr5_U32::operator !=(const algo::LnumStr5_U32 &rhs) const {
 4243    return !algo::LnumStr5_U32_Eq(const_cast<algo::LnumStr5_U32&>(*this),const_cast<algo::LnumStr5_U32&>(rhs));
 4244}
 4245
 4246inline bool algo::LnumStr5_U32::operator ==(const algo::strptr &rhs) const {
 4247    return algo::LnumStr5_U32_EqStrptr(const_cast<algo::LnumStr5_U32&>(*this),rhs);
 4248}
 4249inline algo::LnumStr5_U32::LnumStr5_U32() {
 4250    algo::LnumStr5_U32_Init(*this);
 4251}
 4252
 4253
 4254// --- algo.LnumStr5_U32.ch.Getary
 4255// Access string as array of chars
 4256inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr5_U32& parent) {
 4257    int len = ch_N(parent);
 4258    algo::aryptr<char> ret((char*)parent.ch, len);
 4259    ret.elems += 5 - len;
 4260    return ret;
 4261}
 4262
 4263// --- algo.LnumStr5_U32.ch.HashStrptr
 4264inline u32 algo::LnumStr5_U32_Hash(u32 prev, const algo::strptr &str) {
 4265    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4266}
 4267
 4268// --- algo.LnumStr5_U32.ch.Init
 4269inline void algo::ch_Init(algo::LnumStr5_U32 &parent) {
 4270    for (int i = 0; i < 5; i++) {
 4271        parent.ch[i] = '0';
 4272    }
 4273}
 4274
 4275// --- algo.LnumStr5_U32.ch.Max
 4276// always return constant 5
 4277inline int algo::ch_Max(algo::LnumStr5_U32& parent) {
 4278    (void)parent;
 4279    return 5;
 4280}
 4281
 4282// --- algo.LnumStr5_U32.ch.N
 4283inline int algo::ch_N(const algo::LnumStr5_U32& parent) {
 4284    u64 ret;
 4285    ret = 0;
 4286    while (ret<5 && parent.ch[ret]==u8('0')) {
 4287        ret++;
 4288    }
 4289    ret = 5 - ret;
 4290    return int(ret);
 4291}
 4292
 4293// --- algo.LnumStr5_U32.ch.AssignStrptr
 4294// Copy from strptr (operator=)
 4295inline void algo::LnumStr5_U32::operator =(const algo::strptr &str) {
 4296    ch_SetStrptr(*this, str);
 4297}
 4298
 4299// --- algo.LnumStr5_U32.ch.Set
 4300// Copy from same type
 4301// Copy value from RHS.
 4302inline void algo::LnumStr5_U32::operator =(const algo::LnumStr5_U32& parent) {
 4303    memcpy(ch, parent.ch, 5);
 4304}
 4305
 4306// --- algo.LnumStr5_U32.ch.Ctor
 4307inline  algo::LnumStr5_U32::LnumStr5_U32(const algo::LnumStr5_U32 &rhs) {
 4308    operator =(rhs);
 4309}
 4310
 4311// --- algo.LnumStr5_U32.ch.CtorStrptr
 4312inline  algo::LnumStr5_U32::LnumStr5_U32(const algo::strptr &rhs) {
 4313    ch_SetStrptr(*this, rhs);
 4314}
 4315
 4316// --- algo.LnumStr5_U32.ch.Cast
 4317inline algo::LnumStr5_U32::operator algo::strptr () const {
 4318    return ch_Getary(*this);
 4319}
 4320
 4321// --- algo.LnumStr5_U32..Cmp
 4322inline i32 algo::LnumStr5_U32_Cmp(algo::LnumStr5_U32& lhs, algo::LnumStr5_U32& rhs) {
 4323    i32 retval = 0;
 4324    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4325    return retval;
 4326}
 4327
 4328// --- algo.LnumStr5_U32..Init
 4329// Set all fields to initial values.
 4330inline void algo::LnumStr5_U32_Init(algo::LnumStr5_U32& parent) {
 4331    for (int i = 0; i < 5; i++) {
 4332        parent.ch[i] = '0';
 4333    }
 4334}
 4335
 4336// --- algo.LnumStr5_U32..Eq
 4337inline bool algo::LnumStr5_U32_Eq(algo::LnumStr5_U32& lhs, algo::LnumStr5_U32& rhs) {
 4338    bool retval = true;
 4339    retval = retval
 4340    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 4341    &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
 4342    return retval;
 4343}
 4344
 4345// --- algo.LnumStr5_U32..EqStrptr
 4346inline bool algo::LnumStr5_U32_EqStrptr(const algo::LnumStr5_U32& lhs, const algo::strptr& rhs) {
 4347    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4348}
 4349
 4350inline bool algo::LnumStr5_U32_Base36::operator ==(const algo::LnumStr5_U32_Base36 &rhs) const {
 4351    return algo::LnumStr5_U32_Base36_Eq(const_cast<algo::LnumStr5_U32_Base36&>(*this),const_cast<algo::LnumStr5_U32_Base36&>(rhs));
 4352}
 4353
 4354inline bool algo::LnumStr5_U32_Base36::operator !=(const algo::LnumStr5_U32_Base36 &rhs) const {
 4355    return !algo::LnumStr5_U32_Base36_Eq(const_cast<algo::LnumStr5_U32_Base36&>(*this),const_cast<algo::LnumStr5_U32_Base36&>(rhs));
 4356}
 4357
 4358inline bool algo::LnumStr5_U32_Base36::operator ==(const algo::strptr &rhs) const {
 4359    return algo::LnumStr5_U32_Base36_EqStrptr(const_cast<algo::LnumStr5_U32_Base36&>(*this),rhs);
 4360}
 4361inline algo::LnumStr5_U32_Base36::LnumStr5_U32_Base36() {
 4362    algo::LnumStr5_U32_Base36_Init(*this);
 4363}
 4364
 4365
 4366// --- algo.LnumStr5_U32_Base36.ch.Getary
 4367// Access string as array of chars
 4368inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr5_U32_Base36& parent) {
 4369    int len = ch_N(parent);
 4370    algo::aryptr<char> ret((char*)parent.ch, len);
 4371    ret.elems += 5 - len;
 4372    return ret;
 4373}
 4374
 4375// --- algo.LnumStr5_U32_Base36.ch.HashStrptr
 4376inline u32 algo::LnumStr5_U32_Base36_Hash(u32 prev, const algo::strptr &str) {
 4377    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4378}
 4379
 4380// --- algo.LnumStr5_U32_Base36.ch.Init
 4381inline void algo::ch_Init(algo::LnumStr5_U32_Base36 &parent) {
 4382    for (int i = 0; i < 5; i++) {
 4383        parent.ch[i] = '0';
 4384    }
 4385}
 4386
 4387// --- algo.LnumStr5_U32_Base36.ch.Max
 4388// always return constant 5
 4389inline int algo::ch_Max(algo::LnumStr5_U32_Base36& parent) {
 4390    (void)parent;
 4391    return 5;
 4392}
 4393
 4394// --- algo.LnumStr5_U32_Base36.ch.N
 4395inline int algo::ch_N(const algo::LnumStr5_U32_Base36& parent) {
 4396    u64 ret;
 4397    ret = 0;
 4398    while (ret<5 && parent.ch[ret]==u8('0')) {
 4399        ret++;
 4400    }
 4401    ret = 5 - ret;
 4402    return int(ret);
 4403}
 4404
 4405// --- algo.LnumStr5_U32_Base36.ch.AssignStrptr
 4406// Copy from strptr (operator=)
 4407inline void algo::LnumStr5_U32_Base36::operator =(const algo::strptr &str) {
 4408    ch_SetStrptr(*this, str);
 4409}
 4410
 4411// --- algo.LnumStr5_U32_Base36.ch.Set
 4412// Copy from same type
 4413// Copy value from RHS.
 4414inline void algo::LnumStr5_U32_Base36::operator =(const algo::LnumStr5_U32_Base36& parent) {
 4415    memcpy(ch, parent.ch, 5);
 4416}
 4417
 4418// --- algo.LnumStr5_U32_Base36.ch.Ctor
 4419inline  algo::LnumStr5_U32_Base36::LnumStr5_U32_Base36(const algo::LnumStr5_U32_Base36 &rhs) {
 4420    operator =(rhs);
 4421}
 4422
 4423// --- algo.LnumStr5_U32_Base36.ch.CtorStrptr
 4424inline  algo::LnumStr5_U32_Base36::LnumStr5_U32_Base36(const algo::strptr &rhs) {
 4425    ch_SetStrptr(*this, rhs);
 4426}
 4427
 4428// --- algo.LnumStr5_U32_Base36.ch.Cast
 4429inline algo::LnumStr5_U32_Base36::operator algo::strptr () const {
 4430    return ch_Getary(*this);
 4431}
 4432
 4433// --- algo.LnumStr5_U32_Base36..Cmp
 4434inline i32 algo::LnumStr5_U32_Base36_Cmp(algo::LnumStr5_U32_Base36& lhs, algo::LnumStr5_U32_Base36& rhs) {
 4435    i32 retval = 0;
 4436    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4437    return retval;
 4438}
 4439
 4440// --- algo.LnumStr5_U32_Base36..Init
 4441// Set all fields to initial values.
 4442inline void algo::LnumStr5_U32_Base36_Init(algo::LnumStr5_U32_Base36& parent) {
 4443    for (int i = 0; i < 5; i++) {
 4444        parent.ch[i] = '0';
 4445    }
 4446}
 4447
 4448// --- algo.LnumStr5_U32_Base36..Eq
 4449inline bool algo::LnumStr5_U32_Base36_Eq(algo::LnumStr5_U32_Base36& lhs, algo::LnumStr5_U32_Base36& rhs) {
 4450    bool retval = true;
 4451    retval = retval
 4452    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 4453    &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
 4454    return retval;
 4455}
 4456
 4457// --- algo.LnumStr5_U32_Base36..EqStrptr
 4458inline bool algo::LnumStr5_U32_Base36_EqStrptr(const algo::LnumStr5_U32_Base36& lhs, const algo::strptr& rhs) {
 4459    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4460}
 4461
 4462inline bool algo::LnumStr6_U32::operator ==(const algo::LnumStr6_U32 &rhs) const {
 4463    return algo::LnumStr6_U32_Eq(const_cast<algo::LnumStr6_U32&>(*this),const_cast<algo::LnumStr6_U32&>(rhs));
 4464}
 4465
 4466inline bool algo::LnumStr6_U32::operator !=(const algo::LnumStr6_U32 &rhs) const {
 4467    return !algo::LnumStr6_U32_Eq(const_cast<algo::LnumStr6_U32&>(*this),const_cast<algo::LnumStr6_U32&>(rhs));
 4468}
 4469
 4470inline bool algo::LnumStr6_U32::operator ==(const algo::strptr &rhs) const {
 4471    return algo::LnumStr6_U32_EqStrptr(const_cast<algo::LnumStr6_U32&>(*this),rhs);
 4472}
 4473inline algo::LnumStr6_U32::LnumStr6_U32() {
 4474    algo::LnumStr6_U32_Init(*this);
 4475}
 4476
 4477
 4478// --- algo.LnumStr6_U32.ch.Getary
 4479// Access string as array of chars
 4480inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr6_U32& parent) {
 4481    int len = ch_N(parent);
 4482    algo::aryptr<char> ret((char*)parent.ch, len);
 4483    ret.elems += 6 - len;
 4484    return ret;
 4485}
 4486
 4487// --- algo.LnumStr6_U32.ch.HashStrptr
 4488inline u32 algo::LnumStr6_U32_Hash(u32 prev, const algo::strptr &str) {
 4489    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4490}
 4491
 4492// --- algo.LnumStr6_U32.ch.Init
 4493inline void algo::ch_Init(algo::LnumStr6_U32 &parent) {
 4494    for (int i = 0; i < 6; i++) {
 4495        parent.ch[i] = '0';
 4496    }
 4497}
 4498
 4499// --- algo.LnumStr6_U32.ch.Max
 4500// always return constant 6
 4501inline int algo::ch_Max(algo::LnumStr6_U32& parent) {
 4502    (void)parent;
 4503    return 6;
 4504}
 4505
 4506// --- algo.LnumStr6_U32.ch.N
 4507inline int algo::ch_N(const algo::LnumStr6_U32& parent) {
 4508    u64 ret;
 4509    ret = 0;
 4510    while (ret<6 && parent.ch[ret]==u8('0')) {
 4511        ret++;
 4512    }
 4513    ret = 6 - ret;
 4514    return int(ret);
 4515}
 4516
 4517// --- algo.LnumStr6_U32.ch.AssignStrptr
 4518// Copy from strptr (operator=)
 4519inline void algo::LnumStr6_U32::operator =(const algo::strptr &str) {
 4520    ch_SetStrptr(*this, str);
 4521}
 4522
 4523// --- algo.LnumStr6_U32.ch.Set
 4524// Copy from same type
 4525// Copy value from RHS.
 4526inline void algo::LnumStr6_U32::operator =(const algo::LnumStr6_U32& parent) {
 4527    memcpy(ch, parent.ch, 6);
 4528}
 4529
 4530// --- algo.LnumStr6_U32.ch.Ctor
 4531inline  algo::LnumStr6_U32::LnumStr6_U32(const algo::LnumStr6_U32 &rhs) {
 4532    operator =(rhs);
 4533}
 4534
 4535// --- algo.LnumStr6_U32.ch.CtorStrptr
 4536inline  algo::LnumStr6_U32::LnumStr6_U32(const algo::strptr &rhs) {
 4537    ch_SetStrptr(*this, rhs);
 4538}
 4539
 4540// --- algo.LnumStr6_U32.ch.Cast
 4541inline algo::LnumStr6_U32::operator algo::strptr () const {
 4542    return ch_Getary(*this);
 4543}
 4544
 4545// --- algo.LnumStr6_U32..Cmp
 4546inline i32 algo::LnumStr6_U32_Cmp(algo::LnumStr6_U32& lhs, algo::LnumStr6_U32& rhs) {
 4547    i32 retval = 0;
 4548    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4549    return retval;
 4550}
 4551
 4552// --- algo.LnumStr6_U32..Init
 4553// Set all fields to initial values.
 4554inline void algo::LnumStr6_U32_Init(algo::LnumStr6_U32& parent) {
 4555    for (int i = 0; i < 6; i++) {
 4556        parent.ch[i] = '0';
 4557    }
 4558}
 4559
 4560// --- algo.LnumStr6_U32..Eq
 4561inline bool algo::LnumStr6_U32_Eq(algo::LnumStr6_U32& lhs, algo::LnumStr6_U32& rhs) {
 4562    bool retval = true;
 4563    retval = retval
 4564    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 4565    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
 4566    return retval;
 4567}
 4568
 4569// --- algo.LnumStr6_U32..EqStrptr
 4570inline bool algo::LnumStr6_U32_EqStrptr(const algo::LnumStr6_U32& lhs, const algo::strptr& rhs) {
 4571    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4572}
 4573
 4574inline bool algo::LnumStr7_U32::operator ==(const algo::LnumStr7_U32 &rhs) const {
 4575    return algo::LnumStr7_U32_Eq(const_cast<algo::LnumStr7_U32&>(*this),const_cast<algo::LnumStr7_U32&>(rhs));
 4576}
 4577
 4578inline bool algo::LnumStr7_U32::operator !=(const algo::LnumStr7_U32 &rhs) const {
 4579    return !algo::LnumStr7_U32_Eq(const_cast<algo::LnumStr7_U32&>(*this),const_cast<algo::LnumStr7_U32&>(rhs));
 4580}
 4581
 4582inline bool algo::LnumStr7_U32::operator ==(const algo::strptr &rhs) const {
 4583    return algo::LnumStr7_U32_EqStrptr(const_cast<algo::LnumStr7_U32&>(*this),rhs);
 4584}
 4585inline algo::LnumStr7_U32::LnumStr7_U32() {
 4586    algo::LnumStr7_U32_Init(*this);
 4587}
 4588
 4589
 4590// --- algo.LnumStr7_U32.ch.Getary
 4591// Access string as array of chars
 4592inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr7_U32& parent) {
 4593    int len = ch_N(parent);
 4594    algo::aryptr<char> ret((char*)parent.ch, len);
 4595    ret.elems += 7 - len;
 4596    return ret;
 4597}
 4598
 4599// --- algo.LnumStr7_U32.ch.HashStrptr
 4600inline u32 algo::LnumStr7_U32_Hash(u32 prev, const algo::strptr &str) {
 4601    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4602}
 4603
 4604// --- algo.LnumStr7_U32.ch.Init
 4605inline void algo::ch_Init(algo::LnumStr7_U32 &parent) {
 4606    for (int i = 0; i < 7; i++) {
 4607        parent.ch[i] = '0';
 4608    }
 4609}
 4610
 4611// --- algo.LnumStr7_U32.ch.Max
 4612// always return constant 7
 4613inline int algo::ch_Max(algo::LnumStr7_U32& parent) {
 4614    (void)parent;
 4615    return 7;
 4616}
 4617
 4618// --- algo.LnumStr7_U32.ch.N
 4619inline int algo::ch_N(const algo::LnumStr7_U32& parent) {
 4620    u64 ret;
 4621    ret = 0;
 4622    while (ret<7 && parent.ch[ret]==u8('0')) {
 4623        ret++;
 4624    }
 4625    ret = 7 - ret;
 4626    return int(ret);
 4627}
 4628
 4629// --- algo.LnumStr7_U32.ch.AssignStrptr
 4630// Copy from strptr (operator=)
 4631inline void algo::LnumStr7_U32::operator =(const algo::strptr &str) {
 4632    ch_SetStrptr(*this, str);
 4633}
 4634
 4635// --- algo.LnumStr7_U32.ch.Set
 4636// Copy from same type
 4637// Copy value from RHS.
 4638inline void algo::LnumStr7_U32::operator =(const algo::LnumStr7_U32& parent) {
 4639    memcpy(ch, parent.ch, 7);
 4640}
 4641
 4642// --- algo.LnumStr7_U32.ch.Ctor
 4643inline  algo::LnumStr7_U32::LnumStr7_U32(const algo::LnumStr7_U32 &rhs) {
 4644    operator =(rhs);
 4645}
 4646
 4647// --- algo.LnumStr7_U32.ch.CtorStrptr
 4648inline  algo::LnumStr7_U32::LnumStr7_U32(const algo::strptr &rhs) {
 4649    ch_SetStrptr(*this, rhs);
 4650}
 4651
 4652// --- algo.LnumStr7_U32.ch.Cast
 4653inline algo::LnumStr7_U32::operator algo::strptr () const {
 4654    return ch_Getary(*this);
 4655}
 4656
 4657// --- algo.LnumStr7_U32..Cmp
 4658inline i32 algo::LnumStr7_U32_Cmp(algo::LnumStr7_U32& lhs, algo::LnumStr7_U32& rhs) {
 4659    i32 retval = 0;
 4660    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4661    return retval;
 4662}
 4663
 4664// --- algo.LnumStr7_U32..Init
 4665// Set all fields to initial values.
 4666inline void algo::LnumStr7_U32_Init(algo::LnumStr7_U32& parent) {
 4667    for (int i = 0; i < 7; i++) {
 4668        parent.ch[i] = '0';
 4669    }
 4670}
 4671
 4672// --- algo.LnumStr7_U32..Eq
 4673inline bool algo::LnumStr7_U32_Eq(algo::LnumStr7_U32& lhs, algo::LnumStr7_U32& rhs) {
 4674    bool retval = true;
 4675    retval = retval
 4676    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 4677    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
 4678    &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
 4679    return retval;
 4680}
 4681
 4682// --- algo.LnumStr7_U32..EqStrptr
 4683inline bool algo::LnumStr7_U32_EqStrptr(const algo::LnumStr7_U32& lhs, const algo::strptr& rhs) {
 4684    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4685}
 4686
 4687inline bool algo::LnumStr7_U32_Base36::operator ==(const algo::LnumStr7_U32_Base36 &rhs) const {
 4688    return algo::LnumStr7_U32_Base36_Eq(const_cast<algo::LnumStr7_U32_Base36&>(*this),const_cast<algo::LnumStr7_U32_Base36&>(rhs));
 4689}
 4690
 4691inline bool algo::LnumStr7_U32_Base36::operator !=(const algo::LnumStr7_U32_Base36 &rhs) const {
 4692    return !algo::LnumStr7_U32_Base36_Eq(const_cast<algo::LnumStr7_U32_Base36&>(*this),const_cast<algo::LnumStr7_U32_Base36&>(rhs));
 4693}
 4694
 4695inline bool algo::LnumStr7_U32_Base36::operator ==(const algo::strptr &rhs) const {
 4696    return algo::LnumStr7_U32_Base36_EqStrptr(const_cast<algo::LnumStr7_U32_Base36&>(*this),rhs);
 4697}
 4698inline algo::LnumStr7_U32_Base36::LnumStr7_U32_Base36() {
 4699    algo::LnumStr7_U32_Base36_Init(*this);
 4700}
 4701
 4702
 4703// --- algo.LnumStr7_U32_Base36.ch.Getary
 4704// Access string as array of chars
 4705inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr7_U32_Base36& parent) {
 4706    int len = ch_N(parent);
 4707    algo::aryptr<char> ret((char*)parent.ch, len);
 4708    ret.elems += 7 - len;
 4709    return ret;
 4710}
 4711
 4712// --- algo.LnumStr7_U32_Base36.ch.HashStrptr
 4713inline u32 algo::LnumStr7_U32_Base36_Hash(u32 prev, const algo::strptr &str) {
 4714    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4715}
 4716
 4717// --- algo.LnumStr7_U32_Base36.ch.Init
 4718inline void algo::ch_Init(algo::LnumStr7_U32_Base36 &parent) {
 4719    for (int i = 0; i < 7; i++) {
 4720        parent.ch[i] = '0';
 4721    }
 4722}
 4723
 4724// --- algo.LnumStr7_U32_Base36.ch.Max
 4725// always return constant 7
 4726inline int algo::ch_Max(algo::LnumStr7_U32_Base36& parent) {
 4727    (void)parent;
 4728    return 7;
 4729}
 4730
 4731// --- algo.LnumStr7_U32_Base36.ch.N
 4732inline int algo::ch_N(const algo::LnumStr7_U32_Base36& parent) {
 4733    u64 ret;
 4734    ret = 0;
 4735    while (ret<7 && parent.ch[ret]==u8('0')) {
 4736        ret++;
 4737    }
 4738    ret = 7 - ret;
 4739    return int(ret);
 4740}
 4741
 4742// --- algo.LnumStr7_U32_Base36.ch.AssignStrptr
 4743// Copy from strptr (operator=)
 4744inline void algo::LnumStr7_U32_Base36::operator =(const algo::strptr &str) {
 4745    ch_SetStrptr(*this, str);
 4746}
 4747
 4748// --- algo.LnumStr7_U32_Base36.ch.Set
 4749// Copy from same type
 4750// Copy value from RHS.
 4751inline void algo::LnumStr7_U32_Base36::operator =(const algo::LnumStr7_U32_Base36& parent) {
 4752    memcpy(ch, parent.ch, 7);
 4753}
 4754
 4755// --- algo.LnumStr7_U32_Base36.ch.Ctor
 4756inline  algo::LnumStr7_U32_Base36::LnumStr7_U32_Base36(const algo::LnumStr7_U32_Base36 &rhs) {
 4757    operator =(rhs);
 4758}
 4759
 4760// --- algo.LnumStr7_U32_Base36.ch.CtorStrptr
 4761inline  algo::LnumStr7_U32_Base36::LnumStr7_U32_Base36(const algo::strptr &rhs) {
 4762    ch_SetStrptr(*this, rhs);
 4763}
 4764
 4765// --- algo.LnumStr7_U32_Base36.ch.Cast
 4766inline algo::LnumStr7_U32_Base36::operator algo::strptr () const {
 4767    return ch_Getary(*this);
 4768}
 4769
 4770// --- algo.LnumStr7_U32_Base36..Cmp
 4771inline i32 algo::LnumStr7_U32_Base36_Cmp(algo::LnumStr7_U32_Base36& lhs, algo::LnumStr7_U32_Base36& rhs) {
 4772    i32 retval = 0;
 4773    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4774    return retval;
 4775}
 4776
 4777// --- algo.LnumStr7_U32_Base36..Init
 4778// Set all fields to initial values.
 4779inline void algo::LnumStr7_U32_Base36_Init(algo::LnumStr7_U32_Base36& parent) {
 4780    for (int i = 0; i < 7; i++) {
 4781        parent.ch[i] = '0';
 4782    }
 4783}
 4784
 4785// --- algo.LnumStr7_U32_Base36..Eq
 4786inline bool algo::LnumStr7_U32_Base36_Eq(algo::LnumStr7_U32_Base36& lhs, algo::LnumStr7_U32_Base36& rhs) {
 4787    bool retval = true;
 4788    retval = retval
 4789    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 4790    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
 4791    &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
 4792    return retval;
 4793}
 4794
 4795// --- algo.LnumStr7_U32_Base36..EqStrptr
 4796inline bool algo::LnumStr7_U32_Base36_EqStrptr(const algo::LnumStr7_U32_Base36& lhs, const algo::strptr& rhs) {
 4797    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4798}
 4799
 4800inline bool algo::LnumStr8_U32::operator ==(const algo::LnumStr8_U32 &rhs) const {
 4801    return algo::LnumStr8_U32_Eq(const_cast<algo::LnumStr8_U32&>(*this),const_cast<algo::LnumStr8_U32&>(rhs));
 4802}
 4803
 4804inline bool algo::LnumStr8_U32::operator !=(const algo::LnumStr8_U32 &rhs) const {
 4805    return !algo::LnumStr8_U32_Eq(const_cast<algo::LnumStr8_U32&>(*this),const_cast<algo::LnumStr8_U32&>(rhs));
 4806}
 4807
 4808inline bool algo::LnumStr8_U32::operator ==(const algo::strptr &rhs) const {
 4809    return algo::LnumStr8_U32_EqStrptr(const_cast<algo::LnumStr8_U32&>(*this),rhs);
 4810}
 4811inline algo::LnumStr8_U32::LnumStr8_U32() {
 4812    algo::LnumStr8_U32_Init(*this);
 4813}
 4814
 4815
 4816// --- algo.LnumStr8_U32.ch.Getary
 4817// Access string as array of chars
 4818inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr8_U32& parent) {
 4819    int len = ch_N(parent);
 4820    algo::aryptr<char> ret((char*)parent.ch, len);
 4821    ret.elems += 8 - len;
 4822    return ret;
 4823}
 4824
 4825// --- algo.LnumStr8_U32.ch.HashStrptr
 4826inline u32 algo::LnumStr8_U32_Hash(u32 prev, const algo::strptr &str) {
 4827    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4828}
 4829
 4830// --- algo.LnumStr8_U32.ch.Init
 4831inline void algo::ch_Init(algo::LnumStr8_U32 &parent) {
 4832    for (int i = 0; i < 8; i++) {
 4833        parent.ch[i] = '0';
 4834    }
 4835}
 4836
 4837// --- algo.LnumStr8_U32.ch.Max
 4838// always return constant 8
 4839inline int algo::ch_Max(algo::LnumStr8_U32& parent) {
 4840    (void)parent;
 4841    return 8;
 4842}
 4843
 4844// --- algo.LnumStr8_U32.ch.N
 4845inline int algo::ch_N(const algo::LnumStr8_U32& parent) {
 4846    u64 ret;
 4847    ret = 0;
 4848    while (ret<8 && parent.ch[ret]==u8('0')) {
 4849        ret++;
 4850    }
 4851    ret = 8 - ret;
 4852    return int(ret);
 4853}
 4854
 4855// --- algo.LnumStr8_U32.ch.AssignStrptr
 4856// Copy from strptr (operator=)
 4857inline void algo::LnumStr8_U32::operator =(const algo::strptr &str) {
 4858    ch_SetStrptr(*this, str);
 4859}
 4860
 4861// --- algo.LnumStr8_U32.ch.Set
 4862// Copy from same type
 4863// Copy value from RHS.
 4864inline void algo::LnumStr8_U32::operator =(const algo::LnumStr8_U32& parent) {
 4865    memcpy(ch, parent.ch, 8);
 4866}
 4867
 4868// --- algo.LnumStr8_U32.ch.Ctor
 4869inline  algo::LnumStr8_U32::LnumStr8_U32(const algo::LnumStr8_U32 &rhs) {
 4870    operator =(rhs);
 4871}
 4872
 4873// --- algo.LnumStr8_U32.ch.CtorStrptr
 4874inline  algo::LnumStr8_U32::LnumStr8_U32(const algo::strptr &rhs) {
 4875    ch_SetStrptr(*this, rhs);
 4876}
 4877
 4878// --- algo.LnumStr8_U32.ch.Cast
 4879inline algo::LnumStr8_U32::operator algo::strptr () const {
 4880    return ch_Getary(*this);
 4881}
 4882
 4883// --- algo.LnumStr8_U32..Cmp
 4884inline i32 algo::LnumStr8_U32_Cmp(algo::LnumStr8_U32& lhs, algo::LnumStr8_U32& rhs) {
 4885    i32 retval = 0;
 4886    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4887    return retval;
 4888}
 4889
 4890// --- algo.LnumStr8_U32..Init
 4891// Set all fields to initial values.
 4892inline void algo::LnumStr8_U32_Init(algo::LnumStr8_U32& parent) {
 4893    for (int i = 0; i < 8; i++) {
 4894        parent.ch[i] = '0';
 4895    }
 4896}
 4897
 4898// --- algo.LnumStr8_U32..Eq
 4899inline bool algo::LnumStr8_U32_Eq(algo::LnumStr8_U32& lhs, algo::LnumStr8_U32& rhs) {
 4900    bool retval = true;
 4901    retval = retval
 4902    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
 4903    return retval;
 4904}
 4905
 4906// --- algo.LnumStr8_U32..EqStrptr
 4907inline bool algo::LnumStr8_U32_EqStrptr(const algo::LnumStr8_U32& lhs, const algo::strptr& rhs) {
 4908    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 4909}
 4910
 4911inline bool algo::LnumStr8_U32_Base16::operator ==(const algo::LnumStr8_U32_Base16 &rhs) const {
 4912    return algo::LnumStr8_U32_Base16_Eq(const_cast<algo::LnumStr8_U32_Base16&>(*this),const_cast<algo::LnumStr8_U32_Base16&>(rhs));
 4913}
 4914
 4915inline bool algo::LnumStr8_U32_Base16::operator !=(const algo::LnumStr8_U32_Base16 &rhs) const {
 4916    return !algo::LnumStr8_U32_Base16_Eq(const_cast<algo::LnumStr8_U32_Base16&>(*this),const_cast<algo::LnumStr8_U32_Base16&>(rhs));
 4917}
 4918
 4919inline bool algo::LnumStr8_U32_Base16::operator ==(const algo::strptr &rhs) const {
 4920    return algo::LnumStr8_U32_Base16_EqStrptr(const_cast<algo::LnumStr8_U32_Base16&>(*this),rhs);
 4921}
 4922inline algo::LnumStr8_U32_Base16::LnumStr8_U32_Base16() {
 4923    algo::LnumStr8_U32_Base16_Init(*this);
 4924}
 4925
 4926
 4927// --- algo.LnumStr8_U32_Base16.ch.Getary
 4928// Access string as array of chars
 4929inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr8_U32_Base16& parent) {
 4930    int len = ch_N(parent);
 4931    algo::aryptr<char> ret((char*)parent.ch, len);
 4932    ret.elems += 8 - len;
 4933    return ret;
 4934}
 4935
 4936// --- algo.LnumStr8_U32_Base16.ch.HashStrptr
 4937inline u32 algo::LnumStr8_U32_Base16_Hash(u32 prev, const algo::strptr &str) {
 4938    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 4939}
 4940
 4941// --- algo.LnumStr8_U32_Base16.ch.Init
 4942inline void algo::ch_Init(algo::LnumStr8_U32_Base16 &parent) {
 4943    for (int i = 0; i < 8; i++) {
 4944        parent.ch[i] = '0';
 4945    }
 4946}
 4947
 4948// --- algo.LnumStr8_U32_Base16.ch.Max
 4949// always return constant 8
 4950inline int algo::ch_Max(algo::LnumStr8_U32_Base16& parent) {
 4951    (void)parent;
 4952    return 8;
 4953}
 4954
 4955// --- algo.LnumStr8_U32_Base16.ch.N
 4956inline int algo::ch_N(const algo::LnumStr8_U32_Base16& parent) {
 4957    u64 ret;
 4958    ret = 0;
 4959    while (ret<8 && parent.ch[ret]==u8('0')) {
 4960        ret++;
 4961    }
 4962    ret = 8 - ret;
 4963    return int(ret);
 4964}
 4965
 4966// --- algo.LnumStr8_U32_Base16.ch.AssignStrptr
 4967// Copy from strptr (operator=)
 4968inline void algo::LnumStr8_U32_Base16::operator =(const algo::strptr &str) {
 4969    ch_SetStrptr(*this, str);
 4970}
 4971
 4972// --- algo.LnumStr8_U32_Base16.ch.Set
 4973// Copy from same type
 4974// Copy value from RHS.
 4975inline void algo::LnumStr8_U32_Base16::operator =(const algo::LnumStr8_U32_Base16& parent) {
 4976    memcpy(ch, parent.ch, 8);
 4977}
 4978
 4979// --- algo.LnumStr8_U32_Base16.ch.Ctor
 4980inline  algo::LnumStr8_U32_Base16::LnumStr8_U32_Base16(const algo::LnumStr8_U32_Base16 &rhs) {
 4981    operator =(rhs);
 4982}
 4983
 4984// --- algo.LnumStr8_U32_Base16.ch.CtorStrptr
 4985inline  algo::LnumStr8_U32_Base16::LnumStr8_U32_Base16(const algo::strptr &rhs) {
 4986    ch_SetStrptr(*this, rhs);
 4987}
 4988
 4989// --- algo.LnumStr8_U32_Base16.ch.Cast
 4990inline algo::LnumStr8_U32_Base16::operator algo::strptr () const {
 4991    return ch_Getary(*this);
 4992}
 4993
 4994// --- algo.LnumStr8_U32_Base16..Cmp
 4995inline i32 algo::LnumStr8_U32_Base16_Cmp(algo::LnumStr8_U32_Base16& lhs, algo::LnumStr8_U32_Base16& rhs) {
 4996    i32 retval = 0;
 4997    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 4998    return retval;
 4999}
 5000
 5001// --- algo.LnumStr8_U32_Base16..Init
 5002// Set all fields to initial values.
 5003inline void algo::LnumStr8_U32_Base16_Init(algo::LnumStr8_U32_Base16& parent) {
 5004    for (int i = 0; i < 8; i++) {
 5005        parent.ch[i] = '0';
 5006    }
 5007}
 5008
 5009// --- algo.LnumStr8_U32_Base16..Eq
 5010inline bool algo::LnumStr8_U32_Base16_Eq(algo::LnumStr8_U32_Base16& lhs, algo::LnumStr8_U32_Base16& rhs) {
 5011    bool retval = true;
 5012    retval = retval
 5013    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
 5014    return retval;
 5015}
 5016
 5017// --- algo.LnumStr8_U32_Base16..EqStrptr
 5018inline bool algo::LnumStr8_U32_Base16_EqStrptr(const algo::LnumStr8_U32_Base16& lhs, const algo::strptr& rhs) {
 5019    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5020}
 5021
 5022inline bool algo::LnumStr8_U64::operator ==(const algo::LnumStr8_U64 &rhs) const {
 5023    return algo::LnumStr8_U64_Eq(const_cast<algo::LnumStr8_U64&>(*this),const_cast<algo::LnumStr8_U64&>(rhs));
 5024}
 5025
 5026inline bool algo::LnumStr8_U64::operator !=(const algo::LnumStr8_U64 &rhs) const {
 5027    return !algo::LnumStr8_U64_Eq(const_cast<algo::LnumStr8_U64&>(*this),const_cast<algo::LnumStr8_U64&>(rhs));
 5028}
 5029
 5030inline bool algo::LnumStr8_U64::operator ==(const algo::strptr &rhs) const {
 5031    return algo::LnumStr8_U64_EqStrptr(const_cast<algo::LnumStr8_U64&>(*this),rhs);
 5032}
 5033inline algo::LnumStr8_U64::LnumStr8_U64() {
 5034    algo::LnumStr8_U64_Init(*this);
 5035}
 5036
 5037
 5038// --- algo.LnumStr8_U64.ch.Getary
 5039// Access string as array of chars
 5040inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr8_U64& parent) {
 5041    int len = ch_N(parent);
 5042    algo::aryptr<char> ret((char*)parent.ch, len);
 5043    ret.elems += 8 - len;
 5044    return ret;
 5045}
 5046
 5047// --- algo.LnumStr8_U64.ch.HashStrptr
 5048inline u32 algo::LnumStr8_U64_Hash(u32 prev, const algo::strptr &str) {
 5049    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5050}
 5051
 5052// --- algo.LnumStr8_U64.ch.Init
 5053inline void algo::ch_Init(algo::LnumStr8_U64 &parent) {
 5054    for (int i = 0; i < 8; i++) {
 5055        parent.ch[i] = '0';
 5056    }
 5057}
 5058
 5059// --- algo.LnumStr8_U64.ch.Max
 5060// always return constant 8
 5061inline int algo::ch_Max(algo::LnumStr8_U64& parent) {
 5062    (void)parent;
 5063    return 8;
 5064}
 5065
 5066// --- algo.LnumStr8_U64.ch.N
 5067inline int algo::ch_N(const algo::LnumStr8_U64& parent) {
 5068    u64 ret;
 5069    ret = 0;
 5070    while (ret<8 && parent.ch[ret]==u8('0')) {
 5071        ret++;
 5072    }
 5073    ret = 8 - ret;
 5074    return int(ret);
 5075}
 5076
 5077// --- algo.LnumStr8_U64.ch.AssignStrptr
 5078// Copy from strptr (operator=)
 5079inline void algo::LnumStr8_U64::operator =(const algo::strptr &str) {
 5080    ch_SetStrptr(*this, str);
 5081}
 5082
 5083// --- algo.LnumStr8_U64.ch.Set
 5084// Copy from same type
 5085// Copy value from RHS.
 5086inline void algo::LnumStr8_U64::operator =(const algo::LnumStr8_U64& parent) {
 5087    memcpy(ch, parent.ch, 8);
 5088}
 5089
 5090// --- algo.LnumStr8_U64.ch.Ctor
 5091inline  algo::LnumStr8_U64::LnumStr8_U64(const algo::LnumStr8_U64 &rhs) {
 5092    operator =(rhs);
 5093}
 5094
 5095// --- algo.LnumStr8_U64.ch.CtorStrptr
 5096inline  algo::LnumStr8_U64::LnumStr8_U64(const algo::strptr &rhs) {
 5097    ch_SetStrptr(*this, rhs);
 5098}
 5099
 5100// --- algo.LnumStr8_U64.ch.Cast
 5101inline algo::LnumStr8_U64::operator algo::strptr () const {
 5102    return ch_Getary(*this);
 5103}
 5104
 5105// --- algo.LnumStr8_U64..Cmp
 5106inline i32 algo::LnumStr8_U64_Cmp(algo::LnumStr8_U64& lhs, algo::LnumStr8_U64& rhs) {
 5107    i32 retval = 0;
 5108    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5109    return retval;
 5110}
 5111
 5112// --- algo.LnumStr8_U64..Init
 5113// Set all fields to initial values.
 5114inline void algo::LnumStr8_U64_Init(algo::LnumStr8_U64& parent) {
 5115    for (int i = 0; i < 8; i++) {
 5116        parent.ch[i] = '0';
 5117    }
 5118}
 5119
 5120// --- algo.LnumStr8_U64..Eq
 5121inline bool algo::LnumStr8_U64_Eq(algo::LnumStr8_U64& lhs, algo::LnumStr8_U64& rhs) {
 5122    bool retval = true;
 5123    retval = retval
 5124    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
 5125    return retval;
 5126}
 5127
 5128// --- algo.LnumStr8_U64..EqStrptr
 5129inline bool algo::LnumStr8_U64_EqStrptr(const algo::LnumStr8_U64& lhs, const algo::strptr& rhs) {
 5130    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5131}
 5132
 5133inline bool algo::LnumStr9_U32::operator ==(const algo::LnumStr9_U32 &rhs) const {
 5134    return algo::LnumStr9_U32_Eq(const_cast<algo::LnumStr9_U32&>(*this),const_cast<algo::LnumStr9_U32&>(rhs));
 5135}
 5136
 5137inline bool algo::LnumStr9_U32::operator !=(const algo::LnumStr9_U32 &rhs) const {
 5138    return !algo::LnumStr9_U32_Eq(const_cast<algo::LnumStr9_U32&>(*this),const_cast<algo::LnumStr9_U32&>(rhs));
 5139}
 5140
 5141inline bool algo::LnumStr9_U32::operator ==(const algo::strptr &rhs) const {
 5142    return algo::LnumStr9_U32_EqStrptr(const_cast<algo::LnumStr9_U32&>(*this),rhs);
 5143}
 5144inline algo::LnumStr9_U32::LnumStr9_U32() {
 5145    algo::LnumStr9_U32_Init(*this);
 5146}
 5147
 5148
 5149// --- algo.LnumStr9_U32.ch.Getary
 5150// Access string as array of chars
 5151inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr9_U32& parent) {
 5152    int len = ch_N(parent);
 5153    algo::aryptr<char> ret((char*)parent.ch, len);
 5154    ret.elems += 9 - len;
 5155    return ret;
 5156}
 5157
 5158// --- algo.LnumStr9_U32.ch.HashStrptr
 5159inline u32 algo::LnumStr9_U32_Hash(u32 prev, const algo::strptr &str) {
 5160    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5161}
 5162
 5163// --- algo.LnumStr9_U32.ch.Init
 5164inline void algo::ch_Init(algo::LnumStr9_U32 &parent) {
 5165    for (int i = 0; i < 9; i++) {
 5166        parent.ch[i] = '0';
 5167    }
 5168}
 5169
 5170// --- algo.LnumStr9_U32.ch.Max
 5171// always return constant 9
 5172inline int algo::ch_Max(algo::LnumStr9_U32& parent) {
 5173    (void)parent;
 5174    return 9;
 5175}
 5176
 5177// --- algo.LnumStr9_U32.ch.N
 5178inline int algo::ch_N(const algo::LnumStr9_U32& parent) {
 5179    u64 ret;
 5180    ret = 0;
 5181    while (ret<9 && parent.ch[ret]==u8('0')) {
 5182        ret++;
 5183    }
 5184    ret = 9 - ret;
 5185    return int(ret);
 5186}
 5187
 5188// --- algo.LnumStr9_U32.ch.AssignStrptr
 5189// Copy from strptr (operator=)
 5190inline void algo::LnumStr9_U32::operator =(const algo::strptr &str) {
 5191    ch_SetStrptr(*this, str);
 5192}
 5193
 5194// --- algo.LnumStr9_U32.ch.Set
 5195// Copy from same type
 5196// Copy value from RHS.
 5197inline void algo::LnumStr9_U32::operator =(const algo::LnumStr9_U32& parent) {
 5198    memcpy(ch, parent.ch, 9);
 5199}
 5200
 5201// --- algo.LnumStr9_U32.ch.Ctor
 5202inline  algo::LnumStr9_U32::LnumStr9_U32(const algo::LnumStr9_U32 &rhs) {
 5203    operator =(rhs);
 5204}
 5205
 5206// --- algo.LnumStr9_U32.ch.CtorStrptr
 5207inline  algo::LnumStr9_U32::LnumStr9_U32(const algo::strptr &rhs) {
 5208    ch_SetStrptr(*this, rhs);
 5209}
 5210
 5211// --- algo.LnumStr9_U32.ch.Cast
 5212inline algo::LnumStr9_U32::operator algo::strptr () const {
 5213    return ch_Getary(*this);
 5214}
 5215
 5216// --- algo.LnumStr9_U32..Cmp
 5217inline i32 algo::LnumStr9_U32_Cmp(algo::LnumStr9_U32& lhs, algo::LnumStr9_U32& rhs) {
 5218    i32 retval = 0;
 5219    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5220    return retval;
 5221}
 5222
 5223// --- algo.LnumStr9_U32..Init
 5224// Set all fields to initial values.
 5225inline void algo::LnumStr9_U32_Init(algo::LnumStr9_U32& parent) {
 5226    for (int i = 0; i < 9; i++) {
 5227        parent.ch[i] = '0';
 5228    }
 5229}
 5230
 5231// --- algo.LnumStr9_U32..Eq
 5232inline bool algo::LnumStr9_U32_Eq(algo::LnumStr9_U32& lhs, algo::LnumStr9_U32& rhs) {
 5233    bool retval = true;
 5234    retval = retval
 5235    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5236    &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
 5237    return retval;
 5238}
 5239
 5240// --- algo.LnumStr9_U32..EqStrptr
 5241inline bool algo::LnumStr9_U32_EqStrptr(const algo::LnumStr9_U32& lhs, const algo::strptr& rhs) {
 5242    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5243}
 5244
 5245inline bool algo::LnumStr9_U64::operator ==(const algo::LnumStr9_U64 &rhs) const {
 5246    return algo::LnumStr9_U64_Eq(const_cast<algo::LnumStr9_U64&>(*this),const_cast<algo::LnumStr9_U64&>(rhs));
 5247}
 5248
 5249inline bool algo::LnumStr9_U64::operator !=(const algo::LnumStr9_U64 &rhs) const {
 5250    return !algo::LnumStr9_U64_Eq(const_cast<algo::LnumStr9_U64&>(*this),const_cast<algo::LnumStr9_U64&>(rhs));
 5251}
 5252
 5253inline bool algo::LnumStr9_U64::operator ==(const algo::strptr &rhs) const {
 5254    return algo::LnumStr9_U64_EqStrptr(const_cast<algo::LnumStr9_U64&>(*this),rhs);
 5255}
 5256inline algo::LnumStr9_U64::LnumStr9_U64() {
 5257    algo::LnumStr9_U64_Init(*this);
 5258}
 5259
 5260
 5261// --- algo.LnumStr9_U64.ch.Getary
 5262// Access string as array of chars
 5263inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr9_U64& parent) {
 5264    int len = ch_N(parent);
 5265    algo::aryptr<char> ret((char*)parent.ch, len);
 5266    ret.elems += 9 - len;
 5267    return ret;
 5268}
 5269
 5270// --- algo.LnumStr9_U64.ch.HashStrptr
 5271inline u32 algo::LnumStr9_U64_Hash(u32 prev, const algo::strptr &str) {
 5272    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5273}
 5274
 5275// --- algo.LnumStr9_U64.ch.Init
 5276inline void algo::ch_Init(algo::LnumStr9_U64 &parent) {
 5277    for (int i = 0; i < 9; i++) {
 5278        parent.ch[i] = '0';
 5279    }
 5280}
 5281
 5282// --- algo.LnumStr9_U64.ch.Max
 5283// always return constant 9
 5284inline int algo::ch_Max(algo::LnumStr9_U64& parent) {
 5285    (void)parent;
 5286    return 9;
 5287}
 5288
 5289// --- algo.LnumStr9_U64.ch.N
 5290inline int algo::ch_N(const algo::LnumStr9_U64& parent) {
 5291    u64 ret;
 5292    ret = 0;
 5293    while (ret<9 && parent.ch[ret]==u8('0')) {
 5294        ret++;
 5295    }
 5296    ret = 9 - ret;
 5297    return int(ret);
 5298}
 5299
 5300// --- algo.LnumStr9_U64.ch.AssignStrptr
 5301// Copy from strptr (operator=)
 5302inline void algo::LnumStr9_U64::operator =(const algo::strptr &str) {
 5303    ch_SetStrptr(*this, str);
 5304}
 5305
 5306// --- algo.LnumStr9_U64.ch.Set
 5307// Copy from same type
 5308// Copy value from RHS.
 5309inline void algo::LnumStr9_U64::operator =(const algo::LnumStr9_U64& parent) {
 5310    memcpy(ch, parent.ch, 9);
 5311}
 5312
 5313// --- algo.LnumStr9_U64.ch.Ctor
 5314inline  algo::LnumStr9_U64::LnumStr9_U64(const algo::LnumStr9_U64 &rhs) {
 5315    operator =(rhs);
 5316}
 5317
 5318// --- algo.LnumStr9_U64.ch.CtorStrptr
 5319inline  algo::LnumStr9_U64::LnumStr9_U64(const algo::strptr &rhs) {
 5320    ch_SetStrptr(*this, rhs);
 5321}
 5322
 5323// --- algo.LnumStr9_U64.ch.Cast
 5324inline algo::LnumStr9_U64::operator algo::strptr () const {
 5325    return ch_Getary(*this);
 5326}
 5327
 5328// --- algo.LnumStr9_U64..Cmp
 5329inline i32 algo::LnumStr9_U64_Cmp(algo::LnumStr9_U64& lhs, algo::LnumStr9_U64& rhs) {
 5330    i32 retval = 0;
 5331    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5332    return retval;
 5333}
 5334
 5335// --- algo.LnumStr9_U64..Init
 5336// Set all fields to initial values.
 5337inline void algo::LnumStr9_U64_Init(algo::LnumStr9_U64& parent) {
 5338    for (int i = 0; i < 9; i++) {
 5339        parent.ch[i] = '0';
 5340    }
 5341}
 5342
 5343// --- algo.LnumStr9_U64..Eq
 5344inline bool algo::LnumStr9_U64_Eq(algo::LnumStr9_U64& lhs, algo::LnumStr9_U64& rhs) {
 5345    bool retval = true;
 5346    retval = retval
 5347    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5348    &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
 5349    return retval;
 5350}
 5351
 5352// --- algo.LnumStr9_U64..EqStrptr
 5353inline bool algo::LnumStr9_U64_EqStrptr(const algo::LnumStr9_U64& lhs, const algo::strptr& rhs) {
 5354    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5355}
 5356
 5357inline bool algo::LspaceStr10::operator ==(const algo::LspaceStr10 &rhs) const {
 5358    return algo::LspaceStr10_Eq(const_cast<algo::LspaceStr10&>(*this),const_cast<algo::LspaceStr10&>(rhs));
 5359}
 5360
 5361inline bool algo::LspaceStr10::operator !=(const algo::LspaceStr10 &rhs) const {
 5362    return !algo::LspaceStr10_Eq(const_cast<algo::LspaceStr10&>(*this),const_cast<algo::LspaceStr10&>(rhs));
 5363}
 5364
 5365inline bool algo::LspaceStr10::operator ==(const algo::strptr &rhs) const {
 5366    return algo::LspaceStr10_EqStrptr(const_cast<algo::LspaceStr10&>(*this),rhs);
 5367}
 5368inline algo::LspaceStr10::LspaceStr10() {
 5369    algo::LspaceStr10_Init(*this);
 5370}
 5371
 5372
 5373// --- algo.LspaceStr10.ch.Getary
 5374// Access string as array of chars
 5375inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr10& parent) {
 5376    int len = ch_N(parent);
 5377    algo::aryptr<char> ret((char*)parent.ch, len);
 5378    ret.elems += 10 - len;
 5379    return ret;
 5380}
 5381
 5382// --- algo.LspaceStr10.ch.HashStrptr
 5383inline u32 algo::LspaceStr10_Hash(u32 prev, const algo::strptr &str) {
 5384    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5385}
 5386
 5387// --- algo.LspaceStr10.ch.Init
 5388inline void algo::ch_Init(algo::LspaceStr10 &parent) {
 5389    memset(parent.ch, ' ', 10);
 5390}
 5391
 5392// --- algo.LspaceStr10.ch.Max
 5393// always return constant 10
 5394inline int algo::ch_Max(algo::LspaceStr10& parent) {
 5395    (void)parent;
 5396    return 10;
 5397}
 5398
 5399// --- algo.LspaceStr10.ch.N
 5400inline int algo::ch_N(const algo::LspaceStr10& parent) {
 5401    u64 ret;
 5402    ret = 0;
 5403    while (ret<10 && parent.ch[ret]==u8(' ')) {
 5404        ret++;
 5405    }
 5406    ret = 10 - ret;
 5407    return int(ret);
 5408}
 5409
 5410// --- algo.LspaceStr10.ch.AssignStrptr
 5411// Copy from strptr (operator=)
 5412inline void algo::LspaceStr10::operator =(const algo::strptr &str) {
 5413    ch_SetStrptr(*this, str);
 5414}
 5415
 5416// --- algo.LspaceStr10.ch.Set
 5417// Copy from same type
 5418// Copy value from RHS.
 5419inline void algo::LspaceStr10::operator =(const algo::LspaceStr10& parent) {
 5420    memcpy(ch, parent.ch, 10);
 5421}
 5422
 5423// --- algo.LspaceStr10.ch.Ctor
 5424inline  algo::LspaceStr10::LspaceStr10(const algo::LspaceStr10 &rhs) {
 5425    operator =(rhs);
 5426}
 5427
 5428// --- algo.LspaceStr10.ch.CtorStrptr
 5429inline  algo::LspaceStr10::LspaceStr10(const algo::strptr &rhs) {
 5430    ch_SetStrptr(*this, rhs);
 5431}
 5432
 5433// --- algo.LspaceStr10.ch.Cast
 5434inline algo::LspaceStr10::operator algo::strptr () const {
 5435    return ch_Getary(*this);
 5436}
 5437
 5438// --- algo.LspaceStr10..Cmp
 5439inline i32 algo::LspaceStr10_Cmp(algo::LspaceStr10& lhs, algo::LspaceStr10& rhs) {
 5440    i32 retval = 0;
 5441    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5442    return retval;
 5443}
 5444
 5445// --- algo.LspaceStr10..Init
 5446// Set all fields to initial values.
 5447inline void algo::LspaceStr10_Init(algo::LspaceStr10& parent) {
 5448    memset(parent.ch, ' ', 10);
 5449}
 5450
 5451// --- algo.LspaceStr10..Eq
 5452inline bool algo::LspaceStr10_Eq(algo::LspaceStr10& lhs, algo::LspaceStr10& rhs) {
 5453    bool retval = true;
 5454    retval = retval
 5455    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5456    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
 5457    return retval;
 5458}
 5459
 5460// --- algo.LspaceStr10..EqStrptr
 5461inline bool algo::LspaceStr10_EqStrptr(const algo::LspaceStr10& lhs, const algo::strptr& rhs) {
 5462    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5463}
 5464
 5465inline bool algo::LspaceStr12::operator ==(const algo::LspaceStr12 &rhs) const {
 5466    return algo::LspaceStr12_Eq(const_cast<algo::LspaceStr12&>(*this),const_cast<algo::LspaceStr12&>(rhs));
 5467}
 5468
 5469inline bool algo::LspaceStr12::operator !=(const algo::LspaceStr12 &rhs) const {
 5470    return !algo::LspaceStr12_Eq(const_cast<algo::LspaceStr12&>(*this),const_cast<algo::LspaceStr12&>(rhs));
 5471}
 5472
 5473inline bool algo::LspaceStr12::operator ==(const algo::strptr &rhs) const {
 5474    return algo::LspaceStr12_EqStrptr(const_cast<algo::LspaceStr12&>(*this),rhs);
 5475}
 5476inline algo::LspaceStr12::LspaceStr12() {
 5477    algo::LspaceStr12_Init(*this);
 5478}
 5479
 5480
 5481// --- algo.LspaceStr12.ch.Getary
 5482// Access string as array of chars
 5483inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr12& parent) {
 5484    int len = ch_N(parent);
 5485    algo::aryptr<char> ret((char*)parent.ch, len);
 5486    ret.elems += 12 - len;
 5487    return ret;
 5488}
 5489
 5490// --- algo.LspaceStr12.ch.HashStrptr
 5491inline u32 algo::LspaceStr12_Hash(u32 prev, const algo::strptr &str) {
 5492    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5493}
 5494
 5495// --- algo.LspaceStr12.ch.Init
 5496inline void algo::ch_Init(algo::LspaceStr12 &parent) {
 5497    memset(parent.ch, ' ', 12);
 5498}
 5499
 5500// --- algo.LspaceStr12.ch.Max
 5501// always return constant 12
 5502inline int algo::ch_Max(algo::LspaceStr12& parent) {
 5503    (void)parent;
 5504    return 12;
 5505}
 5506
 5507// --- algo.LspaceStr12.ch.N
 5508inline int algo::ch_N(const algo::LspaceStr12& parent) {
 5509    u64 ret;
 5510    ret = 0;
 5511    while (ret<12 && parent.ch[ret]==u8(' ')) {
 5512        ret++;
 5513    }
 5514    ret = 12 - ret;
 5515    return int(ret);
 5516}
 5517
 5518// --- algo.LspaceStr12.ch.AssignStrptr
 5519// Copy from strptr (operator=)
 5520inline void algo::LspaceStr12::operator =(const algo::strptr &str) {
 5521    ch_SetStrptr(*this, str);
 5522}
 5523
 5524// --- algo.LspaceStr12.ch.Set
 5525// Copy from same type
 5526// Copy value from RHS.
 5527inline void algo::LspaceStr12::operator =(const algo::LspaceStr12& parent) {
 5528    memcpy(ch, parent.ch, 12);
 5529}
 5530
 5531// --- algo.LspaceStr12.ch.Ctor
 5532inline  algo::LspaceStr12::LspaceStr12(const algo::LspaceStr12 &rhs) {
 5533    operator =(rhs);
 5534}
 5535
 5536// --- algo.LspaceStr12.ch.CtorStrptr
 5537inline  algo::LspaceStr12::LspaceStr12(const algo::strptr &rhs) {
 5538    ch_SetStrptr(*this, rhs);
 5539}
 5540
 5541// --- algo.LspaceStr12.ch.Cast
 5542inline algo::LspaceStr12::operator algo::strptr () const {
 5543    return ch_Getary(*this);
 5544}
 5545
 5546// --- algo.LspaceStr12..Cmp
 5547inline i32 algo::LspaceStr12_Cmp(algo::LspaceStr12& lhs, algo::LspaceStr12& rhs) {
 5548    i32 retval = 0;
 5549    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5550    return retval;
 5551}
 5552
 5553// --- algo.LspaceStr12..Init
 5554// Set all fields to initial values.
 5555inline void algo::LspaceStr12_Init(algo::LspaceStr12& parent) {
 5556    memset(parent.ch, ' ', 12);
 5557}
 5558
 5559// --- algo.LspaceStr12..Eq
 5560inline bool algo::LspaceStr12_Eq(algo::LspaceStr12& lhs, algo::LspaceStr12& rhs) {
 5561    bool retval = true;
 5562    retval = retval
 5563    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5564    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
 5565    return retval;
 5566}
 5567
 5568// --- algo.LspaceStr12..EqStrptr
 5569inline bool algo::LspaceStr12_EqStrptr(const algo::LspaceStr12& lhs, const algo::strptr& rhs) {
 5570    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5571}
 5572
 5573inline bool algo::LspaceStr14::operator ==(const algo::LspaceStr14 &rhs) const {
 5574    return algo::LspaceStr14_Eq(const_cast<algo::LspaceStr14&>(*this),const_cast<algo::LspaceStr14&>(rhs));
 5575}
 5576
 5577inline bool algo::LspaceStr14::operator !=(const algo::LspaceStr14 &rhs) const {
 5578    return !algo::LspaceStr14_Eq(const_cast<algo::LspaceStr14&>(*this),const_cast<algo::LspaceStr14&>(rhs));
 5579}
 5580
 5581inline bool algo::LspaceStr14::operator ==(const algo::strptr &rhs) const {
 5582    return algo::LspaceStr14_EqStrptr(const_cast<algo::LspaceStr14&>(*this),rhs);
 5583}
 5584inline algo::LspaceStr14::LspaceStr14() {
 5585    algo::LspaceStr14_Init(*this);
 5586}
 5587
 5588
 5589// --- algo.LspaceStr14.ch.Getary
 5590// Access string as array of chars
 5591inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr14& parent) {
 5592    int len = ch_N(parent);
 5593    algo::aryptr<char> ret((char*)parent.ch, len);
 5594    ret.elems += 14 - len;
 5595    return ret;
 5596}
 5597
 5598// --- algo.LspaceStr14.ch.HashStrptr
 5599inline u32 algo::LspaceStr14_Hash(u32 prev, const algo::strptr &str) {
 5600    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5601}
 5602
 5603// --- algo.LspaceStr14.ch.Init
 5604inline void algo::ch_Init(algo::LspaceStr14 &parent) {
 5605    memset(parent.ch, ' ', 14);
 5606}
 5607
 5608// --- algo.LspaceStr14.ch.Max
 5609// always return constant 14
 5610inline int algo::ch_Max(algo::LspaceStr14& parent) {
 5611    (void)parent;
 5612    return 14;
 5613}
 5614
 5615// --- algo.LspaceStr14.ch.N
 5616inline int algo::ch_N(const algo::LspaceStr14& parent) {
 5617    u64 ret;
 5618    ret = 0;
 5619    while (ret<14 && parent.ch[ret]==u8(' ')) {
 5620        ret++;
 5621    }
 5622    ret = 14 - ret;
 5623    return int(ret);
 5624}
 5625
 5626// --- algo.LspaceStr14.ch.AssignStrptr
 5627// Copy from strptr (operator=)
 5628inline void algo::LspaceStr14::operator =(const algo::strptr &str) {
 5629    ch_SetStrptr(*this, str);
 5630}
 5631
 5632// --- algo.LspaceStr14.ch.Set
 5633// Copy from same type
 5634// Copy value from RHS.
 5635inline void algo::LspaceStr14::operator =(const algo::LspaceStr14& parent) {
 5636    memcpy(ch, parent.ch, 14);
 5637}
 5638
 5639// --- algo.LspaceStr14.ch.Ctor
 5640inline  algo::LspaceStr14::LspaceStr14(const algo::LspaceStr14 &rhs) {
 5641    operator =(rhs);
 5642}
 5643
 5644// --- algo.LspaceStr14.ch.CtorStrptr
 5645inline  algo::LspaceStr14::LspaceStr14(const algo::strptr &rhs) {
 5646    ch_SetStrptr(*this, rhs);
 5647}
 5648
 5649// --- algo.LspaceStr14.ch.Cast
 5650inline algo::LspaceStr14::operator algo::strptr () const {
 5651    return ch_Getary(*this);
 5652}
 5653
 5654// --- algo.LspaceStr14..Cmp
 5655inline i32 algo::LspaceStr14_Cmp(algo::LspaceStr14& lhs, algo::LspaceStr14& rhs) {
 5656    i32 retval = 0;
 5657    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5658    return retval;
 5659}
 5660
 5661// --- algo.LspaceStr14..Init
 5662// Set all fields to initial values.
 5663inline void algo::LspaceStr14_Init(algo::LspaceStr14& parent) {
 5664    memset(parent.ch, ' ', 14);
 5665}
 5666
 5667// --- algo.LspaceStr14..Eq
 5668inline bool algo::LspaceStr14_Eq(algo::LspaceStr14& lhs, algo::LspaceStr14& rhs) {
 5669    bool retval = true;
 5670    retval = retval
 5671    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5672    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
 5673    &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12);
 5674    return retval;
 5675}
 5676
 5677// --- algo.LspaceStr14..EqStrptr
 5678inline bool algo::LspaceStr14_EqStrptr(const algo::LspaceStr14& lhs, const algo::strptr& rhs) {
 5679    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5680}
 5681
 5682inline bool algo::LspaceStr15::operator ==(const algo::LspaceStr15 &rhs) const {
 5683    return algo::LspaceStr15_Eq(const_cast<algo::LspaceStr15&>(*this),const_cast<algo::LspaceStr15&>(rhs));
 5684}
 5685
 5686inline bool algo::LspaceStr15::operator !=(const algo::LspaceStr15 &rhs) const {
 5687    return !algo::LspaceStr15_Eq(const_cast<algo::LspaceStr15&>(*this),const_cast<algo::LspaceStr15&>(rhs));
 5688}
 5689
 5690inline bool algo::LspaceStr15::operator ==(const algo::strptr &rhs) const {
 5691    return algo::LspaceStr15_EqStrptr(const_cast<algo::LspaceStr15&>(*this),rhs);
 5692}
 5693inline algo::LspaceStr15::LspaceStr15() {
 5694    algo::LspaceStr15_Init(*this);
 5695}
 5696
 5697
 5698// --- algo.LspaceStr15.ch.Getary
 5699// Access string as array of chars
 5700inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr15& parent) {
 5701    int len = ch_N(parent);
 5702    algo::aryptr<char> ret((char*)parent.ch, len);
 5703    ret.elems += 15 - len;
 5704    return ret;
 5705}
 5706
 5707// --- algo.LspaceStr15.ch.HashStrptr
 5708inline u32 algo::LspaceStr15_Hash(u32 prev, const algo::strptr &str) {
 5709    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5710}
 5711
 5712// --- algo.LspaceStr15.ch.Init
 5713inline void algo::ch_Init(algo::LspaceStr15 &parent) {
 5714    memset(parent.ch, ' ', 15);
 5715}
 5716
 5717// --- algo.LspaceStr15.ch.Max
 5718// always return constant 15
 5719inline int algo::ch_Max(algo::LspaceStr15& parent) {
 5720    (void)parent;
 5721    return 15;
 5722}
 5723
 5724// --- algo.LspaceStr15.ch.N
 5725inline int algo::ch_N(const algo::LspaceStr15& parent) {
 5726    u64 ret;
 5727    ret = 0;
 5728    while (ret<15 && parent.ch[ret]==u8(' ')) {
 5729        ret++;
 5730    }
 5731    ret = 15 - ret;
 5732    return int(ret);
 5733}
 5734
 5735// --- algo.LspaceStr15.ch.AssignStrptr
 5736// Copy from strptr (operator=)
 5737inline void algo::LspaceStr15::operator =(const algo::strptr &str) {
 5738    ch_SetStrptr(*this, str);
 5739}
 5740
 5741// --- algo.LspaceStr15.ch.Set
 5742// Copy from same type
 5743// Copy value from RHS.
 5744inline void algo::LspaceStr15::operator =(const algo::LspaceStr15& parent) {
 5745    memcpy(ch, parent.ch, 15);
 5746}
 5747
 5748// --- algo.LspaceStr15.ch.Ctor
 5749inline  algo::LspaceStr15::LspaceStr15(const algo::LspaceStr15 &rhs) {
 5750    operator =(rhs);
 5751}
 5752
 5753// --- algo.LspaceStr15.ch.CtorStrptr
 5754inline  algo::LspaceStr15::LspaceStr15(const algo::strptr &rhs) {
 5755    ch_SetStrptr(*this, rhs);
 5756}
 5757
 5758// --- algo.LspaceStr15.ch.Cast
 5759inline algo::LspaceStr15::operator algo::strptr () const {
 5760    return ch_Getary(*this);
 5761}
 5762
 5763// --- algo.LspaceStr15..Cmp
 5764inline i32 algo::LspaceStr15_Cmp(algo::LspaceStr15& lhs, algo::LspaceStr15& rhs) {
 5765    i32 retval = 0;
 5766    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5767    return retval;
 5768}
 5769
 5770// --- algo.LspaceStr15..Init
 5771// Set all fields to initial values.
 5772inline void algo::LspaceStr15_Init(algo::LspaceStr15& parent) {
 5773    memset(parent.ch, ' ', 15);
 5774}
 5775
 5776// --- algo.LspaceStr15..Eq
 5777inline bool algo::LspaceStr15_Eq(algo::LspaceStr15& lhs, algo::LspaceStr15& rhs) {
 5778    bool retval = true;
 5779    retval = retval
 5780    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5781    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
 5782    &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12)
 5783    &&*(u8*)(lhs.ch+14) == *(u8*)(rhs.ch+14);
 5784    return retval;
 5785}
 5786
 5787// --- algo.LspaceStr15..EqStrptr
 5788inline bool algo::LspaceStr15_EqStrptr(const algo::LspaceStr15& lhs, const algo::strptr& rhs) {
 5789    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5790}
 5791
 5792inline bool algo::LspaceStr20_I64::operator ==(const algo::LspaceStr20_I64 &rhs) const {
 5793    return algo::LspaceStr20_I64_Eq(const_cast<algo::LspaceStr20_I64&>(*this),const_cast<algo::LspaceStr20_I64&>(rhs));
 5794}
 5795
 5796inline bool algo::LspaceStr20_I64::operator !=(const algo::LspaceStr20_I64 &rhs) const {
 5797    return !algo::LspaceStr20_I64_Eq(const_cast<algo::LspaceStr20_I64&>(*this),const_cast<algo::LspaceStr20_I64&>(rhs));
 5798}
 5799
 5800inline bool algo::LspaceStr20_I64::operator ==(const algo::strptr &rhs) const {
 5801    return algo::LspaceStr20_I64_EqStrptr(const_cast<algo::LspaceStr20_I64&>(*this),rhs);
 5802}
 5803inline algo::LspaceStr20_I64::LspaceStr20_I64() {
 5804    algo::LspaceStr20_I64_Init(*this);
 5805}
 5806
 5807
 5808// --- algo.LspaceStr20_I64.ch.Getary
 5809// Access string as array of chars
 5810inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr20_I64& parent) {
 5811    int len = ch_N(parent);
 5812    algo::aryptr<char> ret((char*)parent.ch, len);
 5813    ret.elems += 20 - len;
 5814    return ret;
 5815}
 5816
 5817// --- algo.LspaceStr20_I64.ch.HashStrptr
 5818inline u32 algo::LspaceStr20_I64_Hash(u32 prev, const algo::strptr &str) {
 5819    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5820}
 5821
 5822// --- algo.LspaceStr20_I64.ch.Init
 5823inline void algo::ch_Init(algo::LspaceStr20_I64 &parent) {
 5824    memset(parent.ch, ' ', 20);
 5825}
 5826
 5827// --- algo.LspaceStr20_I64.ch.Max
 5828// always return constant 20
 5829inline int algo::ch_Max(algo::LspaceStr20_I64& parent) {
 5830    (void)parent;
 5831    return 20;
 5832}
 5833
 5834// --- algo.LspaceStr20_I64.ch.N
 5835inline int algo::ch_N(const algo::LspaceStr20_I64& parent) {
 5836    u64 ret;
 5837    ret = 0;
 5838    while (ret<20 && parent.ch[ret]==u8(' ')) {
 5839        ret++;
 5840    }
 5841    ret = 20 - ret;
 5842    return int(ret);
 5843}
 5844
 5845// --- algo.LspaceStr20_I64.ch.AssignStrptr
 5846// Copy from strptr (operator=)
 5847inline void algo::LspaceStr20_I64::operator =(const algo::strptr &str) {
 5848    ch_SetStrptr(*this, str);
 5849}
 5850
 5851// --- algo.LspaceStr20_I64.ch.Set
 5852// Copy from same type
 5853// Copy value from RHS.
 5854inline void algo::LspaceStr20_I64::operator =(const algo::LspaceStr20_I64& parent) {
 5855    memcpy(ch, parent.ch, 20);
 5856}
 5857
 5858// --- algo.LspaceStr20_I64.ch.Ctor
 5859inline  algo::LspaceStr20_I64::LspaceStr20_I64(const algo::LspaceStr20_I64 &rhs) {
 5860    operator =(rhs);
 5861}
 5862
 5863// --- algo.LspaceStr20_I64.ch.CtorStrptr
 5864inline  algo::LspaceStr20_I64::LspaceStr20_I64(const algo::strptr &rhs) {
 5865    ch_SetStrptr(*this, rhs);
 5866}
 5867
 5868// --- algo.LspaceStr20_I64.ch.Cast
 5869inline algo::LspaceStr20_I64::operator algo::strptr () const {
 5870    return ch_Getary(*this);
 5871}
 5872
 5873// --- algo.LspaceStr20_I64..Cmp
 5874inline i32 algo::LspaceStr20_I64_Cmp(algo::LspaceStr20_I64& lhs, algo::LspaceStr20_I64& rhs) {
 5875    i32 retval = 0;
 5876    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5877    return retval;
 5878}
 5879
 5880// --- algo.LspaceStr20_I64..Init
 5881// Set all fields to initial values.
 5882inline void algo::LspaceStr20_I64_Init(algo::LspaceStr20_I64& parent) {
 5883    memset(parent.ch, ' ', 20);
 5884}
 5885
 5886// --- algo.LspaceStr20_I64..Eq
 5887inline bool algo::LspaceStr20_I64_Eq(algo::LspaceStr20_I64& lhs, algo::LspaceStr20_I64& rhs) {
 5888    bool retval = true;
 5889    retval = retval
 5890    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 5891    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 5892    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
 5893    return retval;
 5894}
 5895
 5896// --- algo.LspaceStr20_I64..EqStrptr
 5897inline bool algo::LspaceStr20_I64_EqStrptr(const algo::LspaceStr20_I64& lhs, const algo::strptr& rhs) {
 5898    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 5899}
 5900
 5901inline bool algo::LspaceStr20_U64::operator ==(const algo::LspaceStr20_U64 &rhs) const {
 5902    return algo::LspaceStr20_U64_Eq(const_cast<algo::LspaceStr20_U64&>(*this),const_cast<algo::LspaceStr20_U64&>(rhs));
 5903}
 5904
 5905inline bool algo::LspaceStr20_U64::operator !=(const algo::LspaceStr20_U64 &rhs) const {
 5906    return !algo::LspaceStr20_U64_Eq(const_cast<algo::LspaceStr20_U64&>(*this),const_cast<algo::LspaceStr20_U64&>(rhs));
 5907}
 5908
 5909inline bool algo::LspaceStr20_U64::operator ==(const algo::strptr &rhs) const {
 5910    return algo::LspaceStr20_U64_EqStrptr(const_cast<algo::LspaceStr20_U64&>(*this),rhs);
 5911}
 5912inline algo::LspaceStr20_U64::LspaceStr20_U64() {
 5913    algo::LspaceStr20_U64_Init(*this);
 5914}
 5915
 5916
 5917// --- algo.LspaceStr20_U64.ch.Getary
 5918// Access string as array of chars
 5919inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr20_U64& parent) {
 5920    int len = ch_N(parent);
 5921    algo::aryptr<char> ret((char*)parent.ch, len);
 5922    ret.elems += 20 - len;
 5923    return ret;
 5924}
 5925
 5926// --- algo.LspaceStr20_U64.ch.HashStrptr
 5927inline u32 algo::LspaceStr20_U64_Hash(u32 prev, const algo::strptr &str) {
 5928    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 5929}
 5930
 5931// --- algo.LspaceStr20_U64.ch.Init
 5932inline void algo::ch_Init(algo::LspaceStr20_U64 &parent) {
 5933    memset(parent.ch, ' ', 20);
 5934}
 5935
 5936// --- algo.LspaceStr20_U64.ch.Max
 5937// always return constant 20
 5938inline int algo::ch_Max(algo::LspaceStr20_U64& parent) {
 5939    (void)parent;
 5940    return 20;
 5941}
 5942
 5943// --- algo.LspaceStr20_U64.ch.N
 5944inline int algo::ch_N(const algo::LspaceStr20_U64& parent) {
 5945    u64 ret;
 5946    ret = 0;
 5947    while (ret<20 && parent.ch[ret]==u8(' ')) {
 5948        ret++;
 5949    }
 5950    ret = 20 - ret;
 5951    return int(ret);
 5952}
 5953
 5954// --- algo.LspaceStr20_U64.ch.AssignStrptr
 5955// Copy from strptr (operator=)
 5956inline void algo::LspaceStr20_U64::operator =(const algo::strptr &str) {
 5957    ch_SetStrptr(*this, str);
 5958}
 5959
 5960// --- algo.LspaceStr20_U64.ch.Set
 5961// Copy from same type
 5962// Copy value from RHS.
 5963inline void algo::LspaceStr20_U64::operator =(const algo::LspaceStr20_U64& parent) {
 5964    memcpy(ch, parent.ch, 20);
 5965}
 5966
 5967// --- algo.LspaceStr20_U64.ch.Ctor
 5968inline  algo::LspaceStr20_U64::LspaceStr20_U64(const algo::LspaceStr20_U64 &rhs) {
 5969    operator =(rhs);
 5970}
 5971
 5972// --- algo.LspaceStr20_U64.ch.CtorStrptr
 5973inline  algo::LspaceStr20_U64::LspaceStr20_U64(const algo::strptr &rhs) {
 5974    ch_SetStrptr(*this, rhs);
 5975}
 5976
 5977// --- algo.LspaceStr20_U64.ch.Cast
 5978inline algo::LspaceStr20_U64::operator algo::strptr () const {
 5979    return ch_Getary(*this);
 5980}
 5981
 5982// --- algo.LspaceStr20_U64..Cmp
 5983inline i32 algo::LspaceStr20_U64_Cmp(algo::LspaceStr20_U64& lhs, algo::LspaceStr20_U64& rhs) {
 5984    i32 retval = 0;
 5985    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 5986    return retval;
 5987}
 5988
 5989// --- algo.LspaceStr20_U64..Init
 5990// Set all fields to initial values.
 5991inline void algo::LspaceStr20_U64_Init(algo::LspaceStr20_U64& parent) {
 5992    memset(parent.ch, ' ', 20);
 5993}
 5994
 5995// --- algo.LspaceStr20_U64..Eq
 5996inline bool algo::LspaceStr20_U64_Eq(algo::LspaceStr20_U64& lhs, algo::LspaceStr20_U64& rhs) {
 5997    bool retval = true;
 5998    retval = retval
 5999    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 6000    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 6001    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
 6002    return retval;
 6003}
 6004
 6005// --- algo.LspaceStr20_U64..EqStrptr
 6006inline bool algo::LspaceStr20_U64_EqStrptr(const algo::LspaceStr20_U64& lhs, const algo::strptr& rhs) {
 6007    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6008}
 6009
 6010inline bool algo::LspaceStr3::operator ==(const algo::LspaceStr3 &rhs) const {
 6011    return algo::LspaceStr3_Eq(const_cast<algo::LspaceStr3&>(*this),const_cast<algo::LspaceStr3&>(rhs));
 6012}
 6013
 6014inline bool algo::LspaceStr3::operator !=(const algo::LspaceStr3 &rhs) const {
 6015    return !algo::LspaceStr3_Eq(const_cast<algo::LspaceStr3&>(*this),const_cast<algo::LspaceStr3&>(rhs));
 6016}
 6017
 6018inline bool algo::LspaceStr3::operator ==(const algo::strptr &rhs) const {
 6019    return algo::LspaceStr3_EqStrptr(const_cast<algo::LspaceStr3&>(*this),rhs);
 6020}
 6021inline algo::LspaceStr3::LspaceStr3() {
 6022    algo::LspaceStr3_Init(*this);
 6023}
 6024
 6025
 6026// --- algo.LspaceStr3.ch.Getary
 6027// Access string as array of chars
 6028inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr3& parent) {
 6029    int len = ch_N(parent);
 6030    algo::aryptr<char> ret((char*)parent.ch, len);
 6031    ret.elems += 3 - len;
 6032    return ret;
 6033}
 6034
 6035// --- algo.LspaceStr3.ch.HashStrptr
 6036inline u32 algo::LspaceStr3_Hash(u32 prev, const algo::strptr &str) {
 6037    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6038}
 6039
 6040// --- algo.LspaceStr3.ch.Init
 6041inline void algo::ch_Init(algo::LspaceStr3 &parent) {
 6042    memset(parent.ch, ' ', 3);
 6043}
 6044
 6045// --- algo.LspaceStr3.ch.Max
 6046// always return constant 3
 6047inline int algo::ch_Max(algo::LspaceStr3& parent) {
 6048    (void)parent;
 6049    return 3;
 6050}
 6051
 6052// --- algo.LspaceStr3.ch.N
 6053inline int algo::ch_N(const algo::LspaceStr3& parent) {
 6054    u64 ret;
 6055    ret = 0;
 6056    while (ret<3 && parent.ch[ret]==u8(' ')) {
 6057        ret++;
 6058    }
 6059    ret = 3 - ret;
 6060    return int(ret);
 6061}
 6062
 6063// --- algo.LspaceStr3.ch.AssignStrptr
 6064// Copy from strptr (operator=)
 6065inline void algo::LspaceStr3::operator =(const algo::strptr &str) {
 6066    ch_SetStrptr(*this, str);
 6067}
 6068
 6069// --- algo.LspaceStr3.ch.Set
 6070// Copy from same type
 6071// Copy value from RHS.
 6072inline void algo::LspaceStr3::operator =(const algo::LspaceStr3& parent) {
 6073    memcpy(ch, parent.ch, 3);
 6074}
 6075
 6076// --- algo.LspaceStr3.ch.Ctor
 6077inline  algo::LspaceStr3::LspaceStr3(const algo::LspaceStr3 &rhs) {
 6078    operator =(rhs);
 6079}
 6080
 6081// --- algo.LspaceStr3.ch.CtorStrptr
 6082inline  algo::LspaceStr3::LspaceStr3(const algo::strptr &rhs) {
 6083    ch_SetStrptr(*this, rhs);
 6084}
 6085
 6086// --- algo.LspaceStr3.ch.Cast
 6087inline algo::LspaceStr3::operator algo::strptr () const {
 6088    return ch_Getary(*this);
 6089}
 6090
 6091// --- algo.LspaceStr3..Cmp
 6092inline i32 algo::LspaceStr3_Cmp(algo::LspaceStr3& lhs, algo::LspaceStr3& rhs) {
 6093    i32 retval = 0;
 6094    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6095    return retval;
 6096}
 6097
 6098// --- algo.LspaceStr3..Init
 6099// Set all fields to initial values.
 6100inline void algo::LspaceStr3_Init(algo::LspaceStr3& parent) {
 6101    memset(parent.ch, ' ', 3);
 6102}
 6103
 6104// --- algo.LspaceStr3..Eq
 6105inline bool algo::LspaceStr3_Eq(algo::LspaceStr3& lhs, algo::LspaceStr3& rhs) {
 6106    bool retval = true;
 6107    retval = retval
 6108    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
 6109    &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
 6110    return retval;
 6111}
 6112
 6113// --- algo.LspaceStr3..EqStrptr
 6114inline bool algo::LspaceStr3_EqStrptr(const algo::LspaceStr3& lhs, const algo::strptr& rhs) {
 6115    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6116}
 6117
 6118inline bool algo::LspaceStr3_I16::operator ==(const algo::LspaceStr3_I16 &rhs) const {
 6119    return algo::LspaceStr3_I16_Eq(const_cast<algo::LspaceStr3_I16&>(*this),const_cast<algo::LspaceStr3_I16&>(rhs));
 6120}
 6121
 6122inline bool algo::LspaceStr3_I16::operator !=(const algo::LspaceStr3_I16 &rhs) const {
 6123    return !algo::LspaceStr3_I16_Eq(const_cast<algo::LspaceStr3_I16&>(*this),const_cast<algo::LspaceStr3_I16&>(rhs));
 6124}
 6125
 6126inline bool algo::LspaceStr3_I16::operator ==(const algo::strptr &rhs) const {
 6127    return algo::LspaceStr3_I16_EqStrptr(const_cast<algo::LspaceStr3_I16&>(*this),rhs);
 6128}
 6129inline algo::LspaceStr3_I16::LspaceStr3_I16() {
 6130    algo::LspaceStr3_I16_Init(*this);
 6131}
 6132
 6133
 6134// --- algo.LspaceStr3_I16.ch.Getary
 6135// Access string as array of chars
 6136inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr3_I16& parent) {
 6137    int len = ch_N(parent);
 6138    algo::aryptr<char> ret((char*)parent.ch, len);
 6139    ret.elems += 3 - len;
 6140    return ret;
 6141}
 6142
 6143// --- algo.LspaceStr3_I16.ch.HashStrptr
 6144inline u32 algo::LspaceStr3_I16_Hash(u32 prev, const algo::strptr &str) {
 6145    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6146}
 6147
 6148// --- algo.LspaceStr3_I16.ch.Init
 6149inline void algo::ch_Init(algo::LspaceStr3_I16 &parent) {
 6150    memset(parent.ch, ' ', 3);
 6151}
 6152
 6153// --- algo.LspaceStr3_I16.ch.Max
 6154// always return constant 3
 6155inline int algo::ch_Max(algo::LspaceStr3_I16& parent) {
 6156    (void)parent;
 6157    return 3;
 6158}
 6159
 6160// --- algo.LspaceStr3_I16.ch.N
 6161inline int algo::ch_N(const algo::LspaceStr3_I16& parent) {
 6162    u64 ret;
 6163    ret = 0;
 6164    while (ret<3 && parent.ch[ret]==u8(' ')) {
 6165        ret++;
 6166    }
 6167    ret = 3 - ret;
 6168    return int(ret);
 6169}
 6170
 6171// --- algo.LspaceStr3_I16.ch.AssignStrptr
 6172// Copy from strptr (operator=)
 6173inline void algo::LspaceStr3_I16::operator =(const algo::strptr &str) {
 6174    ch_SetStrptr(*this, str);
 6175}
 6176
 6177// --- algo.LspaceStr3_I16.ch.Set
 6178// Copy from same type
 6179// Copy value from RHS.
 6180inline void algo::LspaceStr3_I16::operator =(const algo::LspaceStr3_I16& parent) {
 6181    memcpy(ch, parent.ch, 3);
 6182}
 6183
 6184// --- algo.LspaceStr3_I16.ch.Ctor
 6185inline  algo::LspaceStr3_I16::LspaceStr3_I16(const algo::LspaceStr3_I16 &rhs) {
 6186    operator =(rhs);
 6187}
 6188
 6189// --- algo.LspaceStr3_I16.ch.CtorStrptr
 6190inline  algo::LspaceStr3_I16::LspaceStr3_I16(const algo::strptr &rhs) {
 6191    ch_SetStrptr(*this, rhs);
 6192}
 6193
 6194// --- algo.LspaceStr3_I16.ch.Cast
 6195inline algo::LspaceStr3_I16::operator algo::strptr () const {
 6196    return ch_Getary(*this);
 6197}
 6198
 6199// --- algo.LspaceStr3_I16..Cmp
 6200inline i32 algo::LspaceStr3_I16_Cmp(algo::LspaceStr3_I16& lhs, algo::LspaceStr3_I16& rhs) {
 6201    i32 retval = 0;
 6202    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6203    return retval;
 6204}
 6205
 6206// --- algo.LspaceStr3_I16..Init
 6207// Set all fields to initial values.
 6208inline void algo::LspaceStr3_I16_Init(algo::LspaceStr3_I16& parent) {
 6209    memset(parent.ch, ' ', 3);
 6210}
 6211
 6212// --- algo.LspaceStr3_I16..Eq
 6213inline bool algo::LspaceStr3_I16_Eq(algo::LspaceStr3_I16& lhs, algo::LspaceStr3_I16& rhs) {
 6214    bool retval = true;
 6215    retval = retval
 6216    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
 6217    &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
 6218    return retval;
 6219}
 6220
 6221// --- algo.LspaceStr3_I16..EqStrptr
 6222inline bool algo::LspaceStr3_I16_EqStrptr(const algo::LspaceStr3_I16& lhs, const algo::strptr& rhs) {
 6223    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6224}
 6225
 6226inline bool algo::LspaceStr4::operator ==(const algo::LspaceStr4 &rhs) const {
 6227    return algo::LspaceStr4_Eq(const_cast<algo::LspaceStr4&>(*this),const_cast<algo::LspaceStr4&>(rhs));
 6228}
 6229
 6230inline bool algo::LspaceStr4::operator !=(const algo::LspaceStr4 &rhs) const {
 6231    return !algo::LspaceStr4_Eq(const_cast<algo::LspaceStr4&>(*this),const_cast<algo::LspaceStr4&>(rhs));
 6232}
 6233
 6234inline bool algo::LspaceStr4::operator ==(const algo::strptr &rhs) const {
 6235    return algo::LspaceStr4_EqStrptr(const_cast<algo::LspaceStr4&>(*this),rhs);
 6236}
 6237inline algo::LspaceStr4::LspaceStr4() {
 6238    algo::LspaceStr4_Init(*this);
 6239}
 6240
 6241
 6242// --- algo.LspaceStr4.ch.Getary
 6243// Access string as array of chars
 6244inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr4& parent) {
 6245    int len = ch_N(parent);
 6246    algo::aryptr<char> ret((char*)parent.ch, len);
 6247    ret.elems += 4 - len;
 6248    return ret;
 6249}
 6250
 6251// --- algo.LspaceStr4.ch.HashStrptr
 6252inline u32 algo::LspaceStr4_Hash(u32 prev, const algo::strptr &str) {
 6253    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6254}
 6255
 6256// --- algo.LspaceStr4.ch.Init
 6257inline void algo::ch_Init(algo::LspaceStr4 &parent) {
 6258    memset(parent.ch, ' ', 4);
 6259}
 6260
 6261// --- algo.LspaceStr4.ch.Max
 6262// always return constant 4
 6263inline int algo::ch_Max(algo::LspaceStr4& parent) {
 6264    (void)parent;
 6265    return 4;
 6266}
 6267
 6268// --- algo.LspaceStr4.ch.N
 6269inline int algo::ch_N(const algo::LspaceStr4& parent) {
 6270    u64 ret;
 6271    ret = 0;
 6272    while (ret<4 && parent.ch[ret]==u8(' ')) {
 6273        ret++;
 6274    }
 6275    ret = 4 - ret;
 6276    return int(ret);
 6277}
 6278
 6279// --- algo.LspaceStr4.ch.AssignStrptr
 6280// Copy from strptr (operator=)
 6281inline void algo::LspaceStr4::operator =(const algo::strptr &str) {
 6282    ch_SetStrptr(*this, str);
 6283}
 6284
 6285// --- algo.LspaceStr4.ch.Set
 6286// Copy from same type
 6287// Copy value from RHS.
 6288inline void algo::LspaceStr4::operator =(const algo::LspaceStr4& parent) {
 6289    memcpy(ch, parent.ch, 4);
 6290}
 6291
 6292// --- algo.LspaceStr4.ch.Ctor
 6293inline  algo::LspaceStr4::LspaceStr4(const algo::LspaceStr4 &rhs) {
 6294    operator =(rhs);
 6295}
 6296
 6297// --- algo.LspaceStr4.ch.CtorStrptr
 6298inline  algo::LspaceStr4::LspaceStr4(const algo::strptr &rhs) {
 6299    ch_SetStrptr(*this, rhs);
 6300}
 6301
 6302// --- algo.LspaceStr4.ch.Cast
 6303inline algo::LspaceStr4::operator algo::strptr () const {
 6304    return ch_Getary(*this);
 6305}
 6306
 6307// --- algo.LspaceStr4..Cmp
 6308inline i32 algo::LspaceStr4_Cmp(algo::LspaceStr4& lhs, algo::LspaceStr4& rhs) {
 6309    i32 retval = 0;
 6310    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6311    return retval;
 6312}
 6313
 6314// --- algo.LspaceStr4..Init
 6315// Set all fields to initial values.
 6316inline void algo::LspaceStr4_Init(algo::LspaceStr4& parent) {
 6317    memset(parent.ch, ' ', 4);
 6318}
 6319
 6320// --- algo.LspaceStr4..Eq
 6321inline bool algo::LspaceStr4_Eq(algo::LspaceStr4& lhs, algo::LspaceStr4& rhs) {
 6322    bool retval = true;
 6323    retval = retval
 6324    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
 6325    return retval;
 6326}
 6327
 6328// --- algo.LspaceStr4..EqStrptr
 6329inline bool algo::LspaceStr4_EqStrptr(const algo::LspaceStr4& lhs, const algo::strptr& rhs) {
 6330    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6331}
 6332
 6333inline bool algo::LspaceStr5::operator ==(const algo::LspaceStr5 &rhs) const {
 6334    return algo::LspaceStr5_Eq(const_cast<algo::LspaceStr5&>(*this),const_cast<algo::LspaceStr5&>(rhs));
 6335}
 6336
 6337inline bool algo::LspaceStr5::operator !=(const algo::LspaceStr5 &rhs) const {
 6338    return !algo::LspaceStr5_Eq(const_cast<algo::LspaceStr5&>(*this),const_cast<algo::LspaceStr5&>(rhs));
 6339}
 6340
 6341inline bool algo::LspaceStr5::operator ==(const algo::strptr &rhs) const {
 6342    return algo::LspaceStr5_EqStrptr(const_cast<algo::LspaceStr5&>(*this),rhs);
 6343}
 6344inline algo::LspaceStr5::LspaceStr5() {
 6345    algo::LspaceStr5_Init(*this);
 6346}
 6347
 6348
 6349// --- algo.LspaceStr5.ch.Getary
 6350// Access string as array of chars
 6351inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr5& parent) {
 6352    int len = ch_N(parent);
 6353    algo::aryptr<char> ret((char*)parent.ch, len);
 6354    ret.elems += 5 - len;
 6355    return ret;
 6356}
 6357
 6358// --- algo.LspaceStr5.ch.HashStrptr
 6359inline u32 algo::LspaceStr5_Hash(u32 prev, const algo::strptr &str) {
 6360    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6361}
 6362
 6363// --- algo.LspaceStr5.ch.Init
 6364inline void algo::ch_Init(algo::LspaceStr5 &parent) {
 6365    memset(parent.ch, ' ', 5);
 6366}
 6367
 6368// --- algo.LspaceStr5.ch.Max
 6369// always return constant 5
 6370inline int algo::ch_Max(algo::LspaceStr5& parent) {
 6371    (void)parent;
 6372    return 5;
 6373}
 6374
 6375// --- algo.LspaceStr5.ch.N
 6376inline int algo::ch_N(const algo::LspaceStr5& parent) {
 6377    u64 ret;
 6378    ret = 0;
 6379    while (ret<5 && parent.ch[ret]==u8(' ')) {
 6380        ret++;
 6381    }
 6382    ret = 5 - ret;
 6383    return int(ret);
 6384}
 6385
 6386// --- algo.LspaceStr5.ch.AssignStrptr
 6387// Copy from strptr (operator=)
 6388inline void algo::LspaceStr5::operator =(const algo::strptr &str) {
 6389    ch_SetStrptr(*this, str);
 6390}
 6391
 6392// --- algo.LspaceStr5.ch.Set
 6393// Copy from same type
 6394// Copy value from RHS.
 6395inline void algo::LspaceStr5::operator =(const algo::LspaceStr5& parent) {
 6396    memcpy(ch, parent.ch, 5);
 6397}
 6398
 6399// --- algo.LspaceStr5.ch.Ctor
 6400inline  algo::LspaceStr5::LspaceStr5(const algo::LspaceStr5 &rhs) {
 6401    operator =(rhs);
 6402}
 6403
 6404// --- algo.LspaceStr5.ch.CtorStrptr
 6405inline  algo::LspaceStr5::LspaceStr5(const algo::strptr &rhs) {
 6406    ch_SetStrptr(*this, rhs);
 6407}
 6408
 6409// --- algo.LspaceStr5.ch.Cast
 6410inline algo::LspaceStr5::operator algo::strptr () const {
 6411    return ch_Getary(*this);
 6412}
 6413
 6414// --- algo.LspaceStr5..Cmp
 6415inline i32 algo::LspaceStr5_Cmp(algo::LspaceStr5& lhs, algo::LspaceStr5& rhs) {
 6416    i32 retval = 0;
 6417    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6418    return retval;
 6419}
 6420
 6421// --- algo.LspaceStr5..Init
 6422// Set all fields to initial values.
 6423inline void algo::LspaceStr5_Init(algo::LspaceStr5& parent) {
 6424    memset(parent.ch, ' ', 5);
 6425}
 6426
 6427// --- algo.LspaceStr5..Eq
 6428inline bool algo::LspaceStr5_Eq(algo::LspaceStr5& lhs, algo::LspaceStr5& rhs) {
 6429    bool retval = true;
 6430    retval = retval
 6431    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 6432    &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
 6433    return retval;
 6434}
 6435
 6436// --- algo.LspaceStr5..EqStrptr
 6437inline bool algo::LspaceStr5_EqStrptr(const algo::LspaceStr5& lhs, const algo::strptr& rhs) {
 6438    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6439}
 6440
 6441inline bool algo::LspaceStr5_I16::operator ==(const algo::LspaceStr5_I16 &rhs) const {
 6442    return algo::LspaceStr5_I16_Eq(const_cast<algo::LspaceStr5_I16&>(*this),const_cast<algo::LspaceStr5_I16&>(rhs));
 6443}
 6444
 6445inline bool algo::LspaceStr5_I16::operator !=(const algo::LspaceStr5_I16 &rhs) const {
 6446    return !algo::LspaceStr5_I16_Eq(const_cast<algo::LspaceStr5_I16&>(*this),const_cast<algo::LspaceStr5_I16&>(rhs));
 6447}
 6448
 6449inline bool algo::LspaceStr5_I16::operator ==(const algo::strptr &rhs) const {
 6450    return algo::LspaceStr5_I16_EqStrptr(const_cast<algo::LspaceStr5_I16&>(*this),rhs);
 6451}
 6452inline algo::LspaceStr5_I16::LspaceStr5_I16() {
 6453    algo::LspaceStr5_I16_Init(*this);
 6454}
 6455
 6456
 6457// --- algo.LspaceStr5_I16.ch.Getary
 6458// Access string as array of chars
 6459inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr5_I16& parent) {
 6460    int len = ch_N(parent);
 6461    algo::aryptr<char> ret((char*)parent.ch, len);
 6462    ret.elems += 5 - len;
 6463    return ret;
 6464}
 6465
 6466// --- algo.LspaceStr5_I16.ch.HashStrptr
 6467inline u32 algo::LspaceStr5_I16_Hash(u32 prev, const algo::strptr &str) {
 6468    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6469}
 6470
 6471// --- algo.LspaceStr5_I16.ch.Init
 6472inline void algo::ch_Init(algo::LspaceStr5_I16 &parent) {
 6473    memset(parent.ch, ' ', 5);
 6474}
 6475
 6476// --- algo.LspaceStr5_I16.ch.Max
 6477// always return constant 5
 6478inline int algo::ch_Max(algo::LspaceStr5_I16& parent) {
 6479    (void)parent;
 6480    return 5;
 6481}
 6482
 6483// --- algo.LspaceStr5_I16.ch.N
 6484inline int algo::ch_N(const algo::LspaceStr5_I16& parent) {
 6485    u64 ret;
 6486    ret = 0;
 6487    while (ret<5 && parent.ch[ret]==u8(' ')) {
 6488        ret++;
 6489    }
 6490    ret = 5 - ret;
 6491    return int(ret);
 6492}
 6493
 6494// --- algo.LspaceStr5_I16.ch.AssignStrptr
 6495// Copy from strptr (operator=)
 6496inline void algo::LspaceStr5_I16::operator =(const algo::strptr &str) {
 6497    ch_SetStrptr(*this, str);
 6498}
 6499
 6500// --- algo.LspaceStr5_I16.ch.Set
 6501// Copy from same type
 6502// Copy value from RHS.
 6503inline void algo::LspaceStr5_I16::operator =(const algo::LspaceStr5_I16& parent) {
 6504    memcpy(ch, parent.ch, 5);
 6505}
 6506
 6507// --- algo.LspaceStr5_I16.ch.Ctor
 6508inline  algo::LspaceStr5_I16::LspaceStr5_I16(const algo::LspaceStr5_I16 &rhs) {
 6509    operator =(rhs);
 6510}
 6511
 6512// --- algo.LspaceStr5_I16.ch.CtorStrptr
 6513inline  algo::LspaceStr5_I16::LspaceStr5_I16(const algo::strptr &rhs) {
 6514    ch_SetStrptr(*this, rhs);
 6515}
 6516
 6517// --- algo.LspaceStr5_I16.ch.Cast
 6518inline algo::LspaceStr5_I16::operator algo::strptr () const {
 6519    return ch_Getary(*this);
 6520}
 6521
 6522// --- algo.LspaceStr5_I16..Cmp
 6523inline i32 algo::LspaceStr5_I16_Cmp(algo::LspaceStr5_I16& lhs, algo::LspaceStr5_I16& rhs) {
 6524    i32 retval = 0;
 6525    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6526    return retval;
 6527}
 6528
 6529// --- algo.LspaceStr5_I16..Init
 6530// Set all fields to initial values.
 6531inline void algo::LspaceStr5_I16_Init(algo::LspaceStr5_I16& parent) {
 6532    memset(parent.ch, ' ', 5);
 6533}
 6534
 6535// --- algo.LspaceStr5_I16..Eq
 6536inline bool algo::LspaceStr5_I16_Eq(algo::LspaceStr5_I16& lhs, algo::LspaceStr5_I16& rhs) {
 6537    bool retval = true;
 6538    retval = retval
 6539    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 6540    &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
 6541    return retval;
 6542}
 6543
 6544// --- algo.LspaceStr5_I16..EqStrptr
 6545inline bool algo::LspaceStr5_I16_EqStrptr(const algo::LspaceStr5_I16& lhs, const algo::strptr& rhs) {
 6546    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6547}
 6548
 6549inline bool algo::LspaceStr6::operator ==(const algo::LspaceStr6 &rhs) const {
 6550    return algo::LspaceStr6_Eq(const_cast<algo::LspaceStr6&>(*this),const_cast<algo::LspaceStr6&>(rhs));
 6551}
 6552
 6553inline bool algo::LspaceStr6::operator !=(const algo::LspaceStr6 &rhs) const {
 6554    return !algo::LspaceStr6_Eq(const_cast<algo::LspaceStr6&>(*this),const_cast<algo::LspaceStr6&>(rhs));
 6555}
 6556
 6557inline bool algo::LspaceStr6::operator ==(const algo::strptr &rhs) const {
 6558    return algo::LspaceStr6_EqStrptr(const_cast<algo::LspaceStr6&>(*this),rhs);
 6559}
 6560inline algo::LspaceStr6::LspaceStr6() {
 6561    algo::LspaceStr6_Init(*this);
 6562}
 6563
 6564
 6565// --- algo.LspaceStr6.ch.Getary
 6566// Access string as array of chars
 6567inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr6& parent) {
 6568    int len = ch_N(parent);
 6569    algo::aryptr<char> ret((char*)parent.ch, len);
 6570    ret.elems += 6 - len;
 6571    return ret;
 6572}
 6573
 6574// --- algo.LspaceStr6.ch.HashStrptr
 6575inline u32 algo::LspaceStr6_Hash(u32 prev, const algo::strptr &str) {
 6576    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6577}
 6578
 6579// --- algo.LspaceStr6.ch.Init
 6580inline void algo::ch_Init(algo::LspaceStr6 &parent) {
 6581    memset(parent.ch, ' ', 6);
 6582}
 6583
 6584// --- algo.LspaceStr6.ch.Max
 6585// always return constant 6
 6586inline int algo::ch_Max(algo::LspaceStr6& parent) {
 6587    (void)parent;
 6588    return 6;
 6589}
 6590
 6591// --- algo.LspaceStr6.ch.N
 6592inline int algo::ch_N(const algo::LspaceStr6& parent) {
 6593    u64 ret;
 6594    ret = 0;
 6595    while (ret<6 && parent.ch[ret]==u8(' ')) {
 6596        ret++;
 6597    }
 6598    ret = 6 - ret;
 6599    return int(ret);
 6600}
 6601
 6602// --- algo.LspaceStr6.ch.AssignStrptr
 6603// Copy from strptr (operator=)
 6604inline void algo::LspaceStr6::operator =(const algo::strptr &str) {
 6605    ch_SetStrptr(*this, str);
 6606}
 6607
 6608// --- algo.LspaceStr6.ch.Set
 6609// Copy from same type
 6610// Copy value from RHS.
 6611inline void algo::LspaceStr6::operator =(const algo::LspaceStr6& parent) {
 6612    memcpy(ch, parent.ch, 6);
 6613}
 6614
 6615// --- algo.LspaceStr6.ch.Ctor
 6616inline  algo::LspaceStr6::LspaceStr6(const algo::LspaceStr6 &rhs) {
 6617    operator =(rhs);
 6618}
 6619
 6620// --- algo.LspaceStr6.ch.CtorStrptr
 6621inline  algo::LspaceStr6::LspaceStr6(const algo::strptr &rhs) {
 6622    ch_SetStrptr(*this, rhs);
 6623}
 6624
 6625// --- algo.LspaceStr6.ch.Cast
 6626inline algo::LspaceStr6::operator algo::strptr () const {
 6627    return ch_Getary(*this);
 6628}
 6629
 6630// --- algo.LspaceStr6..Cmp
 6631inline i32 algo::LspaceStr6_Cmp(algo::LspaceStr6& lhs, algo::LspaceStr6& rhs) {
 6632    i32 retval = 0;
 6633    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6634    return retval;
 6635}
 6636
 6637// --- algo.LspaceStr6..Init
 6638// Set all fields to initial values.
 6639inline void algo::LspaceStr6_Init(algo::LspaceStr6& parent) {
 6640    memset(parent.ch, ' ', 6);
 6641}
 6642
 6643// --- algo.LspaceStr6..Eq
 6644inline bool algo::LspaceStr6_Eq(algo::LspaceStr6& lhs, algo::LspaceStr6& rhs) {
 6645    bool retval = true;
 6646    retval = retval
 6647    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 6648    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
 6649    return retval;
 6650}
 6651
 6652// --- algo.LspaceStr6..EqStrptr
 6653inline bool algo::LspaceStr6_EqStrptr(const algo::LspaceStr6& lhs, const algo::strptr& rhs) {
 6654    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6655}
 6656
 6657inline bool algo::LspaceStr6_U32::operator ==(const algo::LspaceStr6_U32 &rhs) const {
 6658    return algo::LspaceStr6_U32_Eq(const_cast<algo::LspaceStr6_U32&>(*this),const_cast<algo::LspaceStr6_U32&>(rhs));
 6659}
 6660
 6661inline bool algo::LspaceStr6_U32::operator !=(const algo::LspaceStr6_U32 &rhs) const {
 6662    return !algo::LspaceStr6_U32_Eq(const_cast<algo::LspaceStr6_U32&>(*this),const_cast<algo::LspaceStr6_U32&>(rhs));
 6663}
 6664
 6665inline bool algo::LspaceStr6_U32::operator ==(const algo::strptr &rhs) const {
 6666    return algo::LspaceStr6_U32_EqStrptr(const_cast<algo::LspaceStr6_U32&>(*this),rhs);
 6667}
 6668inline algo::LspaceStr6_U32::LspaceStr6_U32() {
 6669    algo::LspaceStr6_U32_Init(*this);
 6670}
 6671
 6672
 6673// --- algo.LspaceStr6_U32.ch.Getary
 6674// Access string as array of chars
 6675inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr6_U32& parent) {
 6676    int len = ch_N(parent);
 6677    algo::aryptr<char> ret((char*)parent.ch, len);
 6678    ret.elems += 6 - len;
 6679    return ret;
 6680}
 6681
 6682// --- algo.LspaceStr6_U32.ch.HashStrptr
 6683inline u32 algo::LspaceStr6_U32_Hash(u32 prev, const algo::strptr &str) {
 6684    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6685}
 6686
 6687// --- algo.LspaceStr6_U32.ch.Init
 6688inline void algo::ch_Init(algo::LspaceStr6_U32 &parent) {
 6689    memset(parent.ch, ' ', 6);
 6690}
 6691
 6692// --- algo.LspaceStr6_U32.ch.Max
 6693// always return constant 6
 6694inline int algo::ch_Max(algo::LspaceStr6_U32& parent) {
 6695    (void)parent;
 6696    return 6;
 6697}
 6698
 6699// --- algo.LspaceStr6_U32.ch.N
 6700inline int algo::ch_N(const algo::LspaceStr6_U32& parent) {
 6701    u64 ret;
 6702    ret = 0;
 6703    while (ret<6 && parent.ch[ret]==u8(' ')) {
 6704        ret++;
 6705    }
 6706    ret = 6 - ret;
 6707    return int(ret);
 6708}
 6709
 6710// --- algo.LspaceStr6_U32.ch.AssignStrptr
 6711// Copy from strptr (operator=)
 6712inline void algo::LspaceStr6_U32::operator =(const algo::strptr &str) {
 6713    ch_SetStrptr(*this, str);
 6714}
 6715
 6716// --- algo.LspaceStr6_U32.ch.Set
 6717// Copy from same type
 6718// Copy value from RHS.
 6719inline void algo::LspaceStr6_U32::operator =(const algo::LspaceStr6_U32& parent) {
 6720    memcpy(ch, parent.ch, 6);
 6721}
 6722
 6723// --- algo.LspaceStr6_U32.ch.Ctor
 6724inline  algo::LspaceStr6_U32::LspaceStr6_U32(const algo::LspaceStr6_U32 &rhs) {
 6725    operator =(rhs);
 6726}
 6727
 6728// --- algo.LspaceStr6_U32.ch.CtorStrptr
 6729inline  algo::LspaceStr6_U32::LspaceStr6_U32(const algo::strptr &rhs) {
 6730    ch_SetStrptr(*this, rhs);
 6731}
 6732
 6733// --- algo.LspaceStr6_U32.ch.Cast
 6734inline algo::LspaceStr6_U32::operator algo::strptr () const {
 6735    return ch_Getary(*this);
 6736}
 6737
 6738// --- algo.LspaceStr6_U32..Cmp
 6739inline i32 algo::LspaceStr6_U32_Cmp(algo::LspaceStr6_U32& lhs, algo::LspaceStr6_U32& rhs) {
 6740    i32 retval = 0;
 6741    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6742    return retval;
 6743}
 6744
 6745// --- algo.LspaceStr6_U32..Init
 6746// Set all fields to initial values.
 6747inline void algo::LspaceStr6_U32_Init(algo::LspaceStr6_U32& parent) {
 6748    memset(parent.ch, ' ', 6);
 6749}
 6750
 6751// --- algo.LspaceStr6_U32..Eq
 6752inline bool algo::LspaceStr6_U32_Eq(algo::LspaceStr6_U32& lhs, algo::LspaceStr6_U32& rhs) {
 6753    bool retval = true;
 6754    retval = retval
 6755    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 6756    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
 6757    return retval;
 6758}
 6759
 6760// --- algo.LspaceStr6_U32..EqStrptr
 6761inline bool algo::LspaceStr6_U32_EqStrptr(const algo::LspaceStr6_U32& lhs, const algo::strptr& rhs) {
 6762    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6763}
 6764
 6765inline bool algo::LspaceStr7_I32_Base36::operator ==(const algo::LspaceStr7_I32_Base36 &rhs) const {
 6766    return algo::LspaceStr7_I32_Base36_Eq(const_cast<algo::LspaceStr7_I32_Base36&>(*this),const_cast<algo::LspaceStr7_I32_Base36&>(rhs));
 6767}
 6768
 6769inline bool algo::LspaceStr7_I32_Base36::operator !=(const algo::LspaceStr7_I32_Base36 &rhs) const {
 6770    return !algo::LspaceStr7_I32_Base36_Eq(const_cast<algo::LspaceStr7_I32_Base36&>(*this),const_cast<algo::LspaceStr7_I32_Base36&>(rhs));
 6771}
 6772
 6773inline bool algo::LspaceStr7_I32_Base36::operator ==(const algo::strptr &rhs) const {
 6774    return algo::LspaceStr7_I32_Base36_EqStrptr(const_cast<algo::LspaceStr7_I32_Base36&>(*this),rhs);
 6775}
 6776inline algo::LspaceStr7_I32_Base36::LspaceStr7_I32_Base36() {
 6777    algo::LspaceStr7_I32_Base36_Init(*this);
 6778}
 6779
 6780
 6781// --- algo.LspaceStr7_I32_Base36.ch.Getary
 6782// Access string as array of chars
 6783inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr7_I32_Base36& parent) {
 6784    int len = ch_N(parent);
 6785    algo::aryptr<char> ret((char*)parent.ch, len);
 6786    ret.elems += 7 - len;
 6787    return ret;
 6788}
 6789
 6790// --- algo.LspaceStr7_I32_Base36.ch.HashStrptr
 6791inline u32 algo::LspaceStr7_I32_Base36_Hash(u32 prev, const algo::strptr &str) {
 6792    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6793}
 6794
 6795// --- algo.LspaceStr7_I32_Base36.ch.Init
 6796inline void algo::ch_Init(algo::LspaceStr7_I32_Base36 &parent) {
 6797    memset(parent.ch, ' ', 7);
 6798}
 6799
 6800// --- algo.LspaceStr7_I32_Base36.ch.Max
 6801// always return constant 7
 6802inline int algo::ch_Max(algo::LspaceStr7_I32_Base36& parent) {
 6803    (void)parent;
 6804    return 7;
 6805}
 6806
 6807// --- algo.LspaceStr7_I32_Base36.ch.N
 6808inline int algo::ch_N(const algo::LspaceStr7_I32_Base36& parent) {
 6809    u64 ret;
 6810    ret = 0;
 6811    while (ret<7 && parent.ch[ret]==u8(' ')) {
 6812        ret++;
 6813    }
 6814    ret = 7 - ret;
 6815    return int(ret);
 6816}
 6817
 6818// --- algo.LspaceStr7_I32_Base36.ch.AssignStrptr
 6819// Copy from strptr (operator=)
 6820inline void algo::LspaceStr7_I32_Base36::operator =(const algo::strptr &str) {
 6821    ch_SetStrptr(*this, str);
 6822}
 6823
 6824// --- algo.LspaceStr7_I32_Base36.ch.Set
 6825// Copy from same type
 6826// Copy value from RHS.
 6827inline void algo::LspaceStr7_I32_Base36::operator =(const algo::LspaceStr7_I32_Base36& parent) {
 6828    memcpy(ch, parent.ch, 7);
 6829}
 6830
 6831// --- algo.LspaceStr7_I32_Base36.ch.Ctor
 6832inline  algo::LspaceStr7_I32_Base36::LspaceStr7_I32_Base36(const algo::LspaceStr7_I32_Base36 &rhs) {
 6833    operator =(rhs);
 6834}
 6835
 6836// --- algo.LspaceStr7_I32_Base36.ch.CtorStrptr
 6837inline  algo::LspaceStr7_I32_Base36::LspaceStr7_I32_Base36(const algo::strptr &rhs) {
 6838    ch_SetStrptr(*this, rhs);
 6839}
 6840
 6841// --- algo.LspaceStr7_I32_Base36.ch.Cast
 6842inline algo::LspaceStr7_I32_Base36::operator algo::strptr () const {
 6843    return ch_Getary(*this);
 6844}
 6845
 6846// --- algo.LspaceStr7_I32_Base36..Cmp
 6847inline i32 algo::LspaceStr7_I32_Base36_Cmp(algo::LspaceStr7_I32_Base36& lhs, algo::LspaceStr7_I32_Base36& rhs) {
 6848    i32 retval = 0;
 6849    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6850    return retval;
 6851}
 6852
 6853// --- algo.LspaceStr7_I32_Base36..Init
 6854// Set all fields to initial values.
 6855inline void algo::LspaceStr7_I32_Base36_Init(algo::LspaceStr7_I32_Base36& parent) {
 6856    memset(parent.ch, ' ', 7);
 6857}
 6858
 6859// --- algo.LspaceStr7_I32_Base36..Eq
 6860inline bool algo::LspaceStr7_I32_Base36_Eq(algo::LspaceStr7_I32_Base36& lhs, algo::LspaceStr7_I32_Base36& rhs) {
 6861    bool retval = true;
 6862    retval = retval
 6863    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
 6864    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
 6865    &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
 6866    return retval;
 6867}
 6868
 6869// --- algo.LspaceStr7_I32_Base36..EqStrptr
 6870inline bool algo::LspaceStr7_I32_Base36_EqStrptr(const algo::LspaceStr7_I32_Base36& lhs, const algo::strptr& rhs) {
 6871    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6872}
 6873
 6874inline bool algo::LspaceStr8::operator ==(const algo::LspaceStr8 &rhs) const {
 6875    return algo::LspaceStr8_Eq(const_cast<algo::LspaceStr8&>(*this),const_cast<algo::LspaceStr8&>(rhs));
 6876}
 6877
 6878inline bool algo::LspaceStr8::operator !=(const algo::LspaceStr8 &rhs) const {
 6879    return !algo::LspaceStr8_Eq(const_cast<algo::LspaceStr8&>(*this),const_cast<algo::LspaceStr8&>(rhs));
 6880}
 6881
 6882inline bool algo::LspaceStr8::operator ==(const algo::strptr &rhs) const {
 6883    return algo::LspaceStr8_EqStrptr(const_cast<algo::LspaceStr8&>(*this),rhs);
 6884}
 6885inline algo::LspaceStr8::LspaceStr8() {
 6886    algo::LspaceStr8_Init(*this);
 6887}
 6888
 6889
 6890// --- algo.LspaceStr8.ch.Getary
 6891// Access string as array of chars
 6892inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr8& parent) {
 6893    int len = ch_N(parent);
 6894    algo::aryptr<char> ret((char*)parent.ch, len);
 6895    ret.elems += 8 - len;
 6896    return ret;
 6897}
 6898
 6899// --- algo.LspaceStr8.ch.HashStrptr
 6900inline u32 algo::LspaceStr8_Hash(u32 prev, const algo::strptr &str) {
 6901    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 6902}
 6903
 6904// --- algo.LspaceStr8.ch.Init
 6905inline void algo::ch_Init(algo::LspaceStr8 &parent) {
 6906    memset(parent.ch, ' ', 8);
 6907}
 6908
 6909// --- algo.LspaceStr8.ch.Max
 6910// always return constant 8
 6911inline int algo::ch_Max(algo::LspaceStr8& parent) {
 6912    (void)parent;
 6913    return 8;
 6914}
 6915
 6916// --- algo.LspaceStr8.ch.N
 6917inline int algo::ch_N(const algo::LspaceStr8& parent) {
 6918    u64 ret;
 6919    ret = 0;
 6920    while (ret<8 && parent.ch[ret]==u8(' ')) {
 6921        ret++;
 6922    }
 6923    ret = 8 - ret;
 6924    return int(ret);
 6925}
 6926
 6927// --- algo.LspaceStr8.ch.AssignStrptr
 6928// Copy from strptr (operator=)
 6929inline void algo::LspaceStr8::operator =(const algo::strptr &str) {
 6930    ch_SetStrptr(*this, str);
 6931}
 6932
 6933// --- algo.LspaceStr8.ch.Set
 6934// Copy from same type
 6935// Copy value from RHS.
 6936inline void algo::LspaceStr8::operator =(const algo::LspaceStr8& parent) {
 6937    memcpy(ch, parent.ch, 8);
 6938}
 6939
 6940// --- algo.LspaceStr8.ch.Ctor
 6941inline  algo::LspaceStr8::LspaceStr8(const algo::LspaceStr8 &rhs) {
 6942    operator =(rhs);
 6943}
 6944
 6945// --- algo.LspaceStr8.ch.CtorStrptr
 6946inline  algo::LspaceStr8::LspaceStr8(const algo::strptr &rhs) {
 6947    ch_SetStrptr(*this, rhs);
 6948}
 6949
 6950// --- algo.LspaceStr8.ch.Cast
 6951inline algo::LspaceStr8::operator algo::strptr () const {
 6952    return ch_Getary(*this);
 6953}
 6954
 6955// --- algo.LspaceStr8..Cmp
 6956inline i32 algo::LspaceStr8_Cmp(algo::LspaceStr8& lhs, algo::LspaceStr8& rhs) {
 6957    i32 retval = 0;
 6958    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 6959    return retval;
 6960}
 6961
 6962// --- algo.LspaceStr8..Init
 6963// Set all fields to initial values.
 6964inline void algo::LspaceStr8_Init(algo::LspaceStr8& parent) {
 6965    memset(parent.ch, ' ', 8);
 6966}
 6967
 6968// --- algo.LspaceStr8..Eq
 6969inline bool algo::LspaceStr8_Eq(algo::LspaceStr8& lhs, algo::LspaceStr8& rhs) {
 6970    bool retval = true;
 6971    retval = retval
 6972    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
 6973    return retval;
 6974}
 6975
 6976// --- algo.LspaceStr8..EqStrptr
 6977inline bool algo::LspaceStr8_EqStrptr(const algo::LspaceStr8& lhs, const algo::strptr& rhs) {
 6978    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 6979}
 6980
 6981inline bool algo::LspaceStr9::operator ==(const algo::LspaceStr9 &rhs) const {
 6982    return algo::LspaceStr9_Eq(const_cast<algo::LspaceStr9&>(*this),const_cast<algo::LspaceStr9&>(rhs));
 6983}
 6984
 6985inline bool algo::LspaceStr9::operator !=(const algo::LspaceStr9 &rhs) const {
 6986    return !algo::LspaceStr9_Eq(const_cast<algo::LspaceStr9&>(*this),const_cast<algo::LspaceStr9&>(rhs));
 6987}
 6988
 6989inline bool algo::LspaceStr9::operator ==(const algo::strptr &rhs) const {
 6990    return algo::LspaceStr9_EqStrptr(const_cast<algo::LspaceStr9&>(*this),rhs);
 6991}
 6992inline algo::LspaceStr9::LspaceStr9() {
 6993    algo::LspaceStr9_Init(*this);
 6994}
 6995
 6996
 6997// --- algo.LspaceStr9.ch.Getary
 6998// Access string as array of chars
 6999inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr9& parent) {
 7000    int len = ch_N(parent);
 7001    algo::aryptr<char> ret((char*)parent.ch, len);
 7002    ret.elems += 9 - len;
 7003    return ret;
 7004}
 7005
 7006// --- algo.LspaceStr9.ch.HashStrptr
 7007inline u32 algo::LspaceStr9_Hash(u32 prev, const algo::strptr &str) {
 7008    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 7009}
 7010
 7011// --- algo.LspaceStr9.ch.Init
 7012inline void algo::ch_Init(algo::LspaceStr9 &parent) {
 7013    memset(parent.ch, ' ', 9);
 7014}
 7015
 7016// --- algo.LspaceStr9.ch.Max
 7017// always return constant 9
 7018inline int algo::ch_Max(algo::LspaceStr9& parent) {
 7019    (void)parent;
 7020    return 9;
 7021}
 7022
 7023// --- algo.LspaceStr9.ch.N
 7024inline int algo::ch_N(const algo::LspaceStr9& parent) {
 7025    u64 ret;
 7026    ret = 0;
 7027    while (ret<9 && parent.ch[ret]==u8(' ')) {
 7028        ret++;
 7029    }
 7030    ret = 9 - ret;
 7031    return int(ret);
 7032}
 7033
 7034// --- algo.LspaceStr9.ch.AssignStrptr
 7035// Copy from strptr (operator=)
 7036inline void algo::LspaceStr9::operator =(const algo::strptr &str) {
 7037    ch_SetStrptr(*this, str);
 7038}
 7039
 7040// --- algo.LspaceStr9.ch.Set
 7041// Copy from same type
 7042// Copy value from RHS.
 7043inline void algo::LspaceStr9::operator =(const algo::LspaceStr9& parent) {
 7044    memcpy(ch, parent.ch, 9);
 7045}
 7046
 7047// --- algo.LspaceStr9.ch.Ctor
 7048inline  algo::LspaceStr9::LspaceStr9(const algo::LspaceStr9 &rhs) {
 7049    operator =(rhs);
 7050}
 7051
 7052// --- algo.LspaceStr9.ch.CtorStrptr
 7053inline  algo::LspaceStr9::LspaceStr9(const algo::strptr &rhs) {
 7054    ch_SetStrptr(*this, rhs);
 7055}
 7056
 7057// --- algo.LspaceStr9.ch.Cast
 7058inline algo::LspaceStr9::operator algo::strptr () const {
 7059    return ch_Getary(*this);
 7060}
 7061
 7062// --- algo.LspaceStr9..Cmp
 7063inline i32 algo::LspaceStr9_Cmp(algo::LspaceStr9& lhs, algo::LspaceStr9& rhs) {
 7064    i32 retval = 0;
 7065    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 7066    return retval;
 7067}
 7068
 7069// --- algo.LspaceStr9..Init
 7070// Set all fields to initial values.
 7071inline void algo::LspaceStr9_Init(algo::LspaceStr9& parent) {
 7072    memset(parent.ch, ' ', 9);
 7073}
 7074
 7075// --- algo.LspaceStr9..Eq
 7076inline bool algo::LspaceStr9_Eq(algo::LspaceStr9& lhs, algo::LspaceStr9& rhs) {
 7077    bool retval = true;
 7078    retval = retval
 7079    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 7080    &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
 7081    return retval;
 7082}
 7083
 7084// --- algo.LspaceStr9..EqStrptr
 7085inline bool algo::LspaceStr9_EqStrptr(const algo::LspaceStr9& lhs, const algo::strptr& rhs) {
 7086    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 7087}
 7088inline algo::Md5Digest::Md5Digest(algo::aryptr<u8 >              in_value)
 7089{
 7090    value_Setary(*this, in_value);
 7091}
 7092inline algo::Md5Digest::Md5Digest() {
 7093    algo::Md5Digest_Init(*this);
 7094}
 7095
 7096
 7097// --- algo.Md5Digest.value.Fill
 7098// Set all elements of fixed array to value RHS
 7099inline void algo::value_Fill(algo::Md5Digest& parent, const u8 &rhs) {
 7100    for (int i = 0; i < 16; i++) {
 7101        parent.value_elems[i] = rhs;
 7102    }
 7103}
 7104
 7105// --- algo.Md5Digest.value.Find
 7106// Look up row by row id. Return NULL if out of range
 7107inline u8* algo::value_Find(algo::Md5Digest& parent, u64 t) {
 7108    u64 idx = t;
 7109    u64 lim = 16;
 7110    return idx < lim ? parent.value_elems + idx : NULL; // unsigned comparison with limit
 7111}
 7112
 7113// --- algo.Md5Digest.value.Getary
 7114// Access fixed array value as aryptr.
 7115inline algo::aryptr<u8> algo::value_Getary(algo::Md5Digest& parent) {
 7116    return algo::aryptr<u8>(parent.value_elems, 16);
 7117}
 7118
 7119// --- algo.Md5Digest.value.Max
 7120// Return max number of items in the array
 7121inline i32 algo::value_Max(algo::Md5Digest& parent) {
 7122    (void)parent;
 7123    return 16;
 7124}
 7125
 7126// --- algo.Md5Digest.value.N
 7127// Return number of items in the array
 7128inline i32 algo::value_N(const algo::Md5Digest& parent) {
 7129    (void)parent;//only to avoid -Wunused-parameter
 7130    return 16;
 7131}
 7132
 7133// --- algo.Md5Digest.value.Setary
 7134// Set contents of fixed array to RHS; Input length is trimmed as necessary
 7135inline void algo::value_Setary(algo::Md5Digest& parent, const algo::aryptr<u8> &rhs) {
 7136    int n = 16 < rhs.n_elems ? 16 : rhs.n_elems;
 7137    for (int i = 0; i < n; i++) {
 7138        parent.value_elems[i] = rhs[i];
 7139    }
 7140}
 7141
 7142// --- algo.Md5Digest.value.qFind
 7143// 'quick' Access row by row id. No bounds checking in release.
 7144inline u8& algo::value_qFind(algo::Md5Digest& parent, u64 t) {
 7145    return parent.value_elems[u64(t)];
 7146}
 7147
 7148// --- algo.Md5Digest.value_curs.Reset
 7149// cursor points to valid item
 7150inline void algo::Md5Digest_value_curs_Reset(Md5Digest_value_curs &curs, algo::Md5Digest &parent) {
 7151    curs.parent = &parent;
 7152    curs.index = 0;
 7153}
 7154
 7155// --- algo.Md5Digest.value_curs.ValidQ
 7156// cursor points to valid item
 7157inline bool algo::Md5Digest_value_curs_ValidQ(Md5Digest_value_curs &curs) {
 7158    return u64(curs.index) < u64(16);
 7159}
 7160
 7161// --- algo.Md5Digest.value_curs.Next
 7162// proceed to next item
 7163inline void algo::Md5Digest_value_curs_Next(Md5Digest_value_curs &curs) {
 7164    curs.index++;
 7165}
 7166
 7167// --- algo.Md5Digest.value_curs.Access
 7168// item access
 7169inline u8& algo::Md5Digest_value_curs_Access(Md5Digest_value_curs &curs) {
 7170    return value_qFind((*curs.parent), u64(curs.index));
 7171}
 7172
 7173// --- algo.Md5Digest..Init
 7174// Set all fields to initial values.
 7175inline void algo::Md5Digest_Init(algo::Md5Digest& parent) {
 7176    for (int i = 0; i < 16; i++) {
 7177        parent.value_elems[i] = 0;
 7178    }
 7179}
 7180inline algo::Month::Month(u32                            in_value)
 7181    : value(in_value)
 7182{
 7183}
 7184inline algo::Month::Month(algo_MonthEnum arg) { this->value = u32(arg); }
 7185inline algo::Month::Month() {
 7186    algo::Month_Init(*this);
 7187}
 7188
 7189
 7190// --- algo.Month.value.GetEnum
 7191// Get value of field as enum type
 7192inline algo_MonthEnum algo::value_GetEnum(const algo::Month& parent) {
 7193    return algo_MonthEnum(parent.value);
 7194}
 7195
 7196// --- algo.Month.value.SetEnum
 7197// Set value of field from enum type.
 7198inline void algo::value_SetEnum(algo::Month& parent, algo_MonthEnum rhs) {
 7199    parent.value = u32(rhs);
 7200}
 7201
 7202// --- algo.Month.value.Cast
 7203inline algo::Month::operator algo_MonthEnum () const {
 7204    return algo_MonthEnum((*this).value);
 7205}
 7206
 7207// --- algo.Month..Init
 7208// Set all fields to initial values.
 7209inline void algo::Month_Init(algo::Month& parent) {
 7210    parent.value = u32(0);
 7211}
 7212inline algo::NumParseFlags::NumParseFlags(u32                            in_value)
 7213    : value(in_value)
 7214{
 7215}
 7216inline algo::NumParseFlags::NumParseFlags(algo_NumParseFlagsEnum arg) { this->value = u32(arg); }
 7217inline algo::NumParseFlags::NumParseFlags() {
 7218    algo::NumParseFlags_Init(*this);
 7219}
 7220
 7221
 7222// --- algo.NumParseFlags.value.Cast
 7223inline algo::NumParseFlags::operator algo_NumParseFlagsEnum () const {
 7224    return algo_NumParseFlagsEnum((*this).value);
 7225}
 7226
 7227// --- algo.NumParseFlags.err.Get
 7228// Retrieve bitfield from value of field value
 7229//    1 bits starting at bit 0.
 7230inline bool algo::err_Get(const algo::NumParseFlags& parent) {
 7231    return bool((parent.value >> 0) & 0x01);
 7232}
 7233
 7234// --- algo.NumParseFlags.err.Set
 7235// Set bitfield in value of field 'value'
 7236//    1 bits starting at bit 0.
 7237inline void algo::err_Set(algo::NumParseFlags& parent, bool rhs) {
 7238    u32 t1    = u32(0x01) << 0;
 7239    u32 t2    = (u32(rhs) & 0x01) << 0;
 7240    parent.value = u32((parent.value & ~t1) | t2);
 7241}
 7242
 7243// --- algo.NumParseFlags.ok.Get
 7244// Retrieve bitfield from value of field value
 7245//    1 bits starting at bit 1.
 7246inline bool algo::ok_Get(const algo::NumParseFlags& parent) {
 7247    return bool((parent.value >> 1) & 0x01);
 7248}
 7249
 7250// --- algo.NumParseFlags.ok.Set
 7251// Set bitfield in value of field 'value'
 7252//    1 bits starting at bit 1.
 7253inline void algo::ok_Set(algo::NumParseFlags& parent, bool rhs) {
 7254    u32 t1    = u32(0x01) << 1;
 7255    u32 t2    = (u32(rhs) & 0x01) << 1;
 7256    parent.value = u32((parent.value & ~t1) | t2);
 7257}
 7258
 7259// --- algo.NumParseFlags.neg.Get
 7260// Retrieve bitfield from value of field value
 7261//    1 bits starting at bit 2.
 7262inline bool algo::neg_Get(const algo::NumParseFlags& parent) {
 7263    return bool((parent.value >> 2) & 0x01);
 7264}
 7265
 7266// --- algo.NumParseFlags.neg.Set
 7267// Set bitfield in value of field 'value'
 7268//    1 bits starting at bit 2.
 7269inline void algo::neg_Set(algo::NumParseFlags& parent, bool rhs) {
 7270    u32 t1    = u32(0x01) << 2;
 7271    u32 t2    = (u32(rhs) & 0x01) << 2;
 7272    parent.value = u32((parent.value & ~t1) | t2);
 7273}
 7274
 7275// --- algo.NumParseFlags.overflow.Get
 7276// Retrieve bitfield from value of field value
 7277//    1 bits starting at bit 3.
 7278inline bool algo::overflow_Get(const algo::NumParseFlags& parent) {
 7279    return bool((parent.value >> 3) & 0x01);
 7280}
 7281
 7282// --- algo.NumParseFlags.overflow.Set
 7283// Set bitfield in value of field 'value'
 7284//    1 bits starting at bit 3.
 7285inline void algo::overflow_Set(algo::NumParseFlags& parent, bool rhs) {
 7286    u32 t1    = u32(0x01) << 3;
 7287    u32 t2    = (u32(rhs) & 0x01) << 3;
 7288    parent.value = u32((parent.value & ~t1) | t2);
 7289}
 7290
 7291// --- algo.NumParseFlags.hex.Get
 7292// Retrieve bitfield from value of field value
 7293//    1 bits starting at bit 4.
 7294inline bool algo::hex_Get(const algo::NumParseFlags& parent) {
 7295    return bool((parent.value >> 4) & 0x01);
 7296}
 7297
 7298// --- algo.NumParseFlags.hex.Set
 7299// Set bitfield in value of field 'value'
 7300//    1 bits starting at bit 4.
 7301inline void algo::hex_Set(algo::NumParseFlags& parent, bool rhs) {
 7302    u32 t1    = u32(0x01) << 4;
 7303    u32 t2    = (u32(rhs) & 0x01) << 4;
 7304    parent.value = u32((parent.value & ~t1) | t2);
 7305}
 7306
 7307// --- algo.NumParseFlags..Init
 7308// Set all fields to initial values.
 7309inline void algo::NumParseFlags_Init(algo::NumParseFlags& parent) {
 7310    parent.value = u32(0);
 7311}
 7312
 7313inline bool algo::RnullStr1::operator ==(const algo::RnullStr1 &rhs) const {
 7314    return algo::RnullStr1_Eq(const_cast<algo::RnullStr1&>(*this),const_cast<algo::RnullStr1&>(rhs));
 7315}
 7316
 7317inline bool algo::RnullStr1::operator !=(const algo::RnullStr1 &rhs) const {
 7318    return !algo::RnullStr1_Eq(const_cast<algo::RnullStr1&>(*this),const_cast<algo::RnullStr1&>(rhs));
 7319}
 7320
 7321inline bool algo::RnullStr1::operator ==(const algo::strptr &rhs) const {
 7322    return algo::RnullStr1_EqStrptr(const_cast<algo::RnullStr1&>(*this),rhs);
 7323}
 7324
 7325inline bool algo::RnullStr1::operator <(const algo::RnullStr1 &rhs) const {
 7326    return algo::RnullStr1_Lt(const_cast<algo::RnullStr1&>(*this),const_cast<algo::RnullStr1&>(rhs));
 7327}
 7328
 7329inline bool algo::RnullStr1::operator >(const algo::RnullStr1 &rhs) const {
 7330    return rhs < *this;
 7331}
 7332
 7333inline bool algo::RnullStr1::operator <=(const algo::RnullStr1 &rhs) const {
 7334    return !(rhs < *this);
 7335}
 7336
 7337inline bool algo::RnullStr1::operator >=(const algo::RnullStr1 &rhs) const {
 7338    return !(*this < rhs);
 7339}
 7340inline algo::RnullStr1::RnullStr1() {
 7341    algo::RnullStr1_Init(*this);
 7342}
 7343
 7344
 7345// --- algo.RnullStr1.ch.Getary
 7346// Access string as array of chars
 7347inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr1& parent) {
 7348    int len = ch_N(parent);
 7349    algo::aryptr<char> ret((char*)parent.ch, len);
 7350    return ret;
 7351}
 7352
 7353// --- algo.RnullStr1.ch.HashStrptr
 7354inline u32 algo::RnullStr1_Hash(u32 prev, const algo::strptr &str) {
 7355    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 7356}
 7357
 7358// --- algo.RnullStr1.ch.Init
 7359inline void algo::ch_Init(algo::RnullStr1 &parent) {
 7360    memset(parent.ch, 0, 1);
 7361}
 7362
 7363// --- algo.RnullStr1.ch.Max
 7364// always return constant 1
 7365inline int algo::ch_Max(algo::RnullStr1& parent) {
 7366    (void)parent;
 7367    return 1;
 7368}
 7369
 7370// --- algo.RnullStr1.ch.N
 7371inline int algo::ch_N(const algo::RnullStr1& parent) {
 7372    u64 ret;
 7373    ret = 1;
 7374    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 7375        ret--;
 7376    }
 7377    return int(ret);
 7378}
 7379
 7380// --- algo.RnullStr1.ch.AssignStrptr
 7381// Copy from strptr (operator=)
 7382inline void algo::RnullStr1::operator =(const algo::strptr &str) {
 7383    ch_SetStrptr(*this, str);
 7384}
 7385
 7386// --- algo.RnullStr1.ch.Set
 7387// Copy from same type
 7388// Copy value from RHS.
 7389inline void algo::RnullStr1::operator =(const algo::RnullStr1& parent) {
 7390    memcpy(ch, parent.ch, 1);
 7391}
 7392
 7393// --- algo.RnullStr1.ch.Ctor
 7394inline  algo::RnullStr1::RnullStr1(const algo::RnullStr1 &rhs) {
 7395    operator =(rhs);
 7396}
 7397
 7398// --- algo.RnullStr1.ch.CtorStrptr
 7399inline  algo::RnullStr1::RnullStr1(const algo::strptr &rhs) {
 7400    ch_SetStrptr(*this, rhs);
 7401}
 7402
 7403// --- algo.RnullStr1.ch.Cast
 7404inline algo::RnullStr1::operator algo::strptr () const {
 7405    return ch_Getary(*this);
 7406}
 7407
 7408// --- algo.RnullStr1..Lt
 7409inline bool algo::RnullStr1_Lt(algo::RnullStr1 lhs, algo::RnullStr1 rhs) {
 7410    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 7411}
 7412
 7413// --- algo.RnullStr1..Cmp
 7414inline i32 algo::RnullStr1_Cmp(algo::RnullStr1 lhs, algo::RnullStr1 rhs) {
 7415    i32 retval = 0;
 7416    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 7417    return retval;
 7418}
 7419
 7420// --- algo.RnullStr1..Init
 7421// Set all fields to initial values.
 7422inline void algo::RnullStr1_Init(algo::RnullStr1& parent) {
 7423    memset(parent.ch, 0, 1);
 7424}
 7425
 7426// --- algo.RnullStr1..Eq
 7427inline bool algo::RnullStr1_Eq(algo::RnullStr1 lhs, algo::RnullStr1 rhs) {
 7428    bool retval = true;
 7429    retval = retval
 7430    &&*(u8*)(lhs.ch+0) == *(u8*)(rhs.ch+0);
 7431    return retval;
 7432}
 7433
 7434// --- algo.RnullStr1..Update
 7435// Set value. Return true if new value is different from old value.
 7436inline bool algo::RnullStr1_Update(algo::RnullStr1 &lhs, algo::RnullStr1 rhs) {
 7437    bool ret = !RnullStr1_Eq(lhs, rhs); // compare values
 7438    if (ret) {
 7439        lhs = rhs; // update
 7440    }
 7441    return ret;
 7442}
 7443
 7444// --- algo.RnullStr1..EqStrptr
 7445inline bool algo::RnullStr1_EqStrptr(algo::RnullStr1 lhs, const algo::strptr& rhs) {
 7446    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 7447}
 7448
 7449inline bool algo::RnullStr10::operator ==(const algo::RnullStr10 &rhs) const {
 7450    return algo::RnullStr10_Eq(const_cast<algo::RnullStr10&>(*this),const_cast<algo::RnullStr10&>(rhs));
 7451}
 7452
 7453inline bool algo::RnullStr10::operator !=(const algo::RnullStr10 &rhs) const {
 7454    return !algo::RnullStr10_Eq(const_cast<algo::RnullStr10&>(*this),const_cast<algo::RnullStr10&>(rhs));
 7455}
 7456
 7457inline bool algo::RnullStr10::operator ==(const algo::strptr &rhs) const {
 7458    return algo::RnullStr10_EqStrptr(const_cast<algo::RnullStr10&>(*this),rhs);
 7459}
 7460
 7461inline bool algo::RnullStr10::operator <(const algo::RnullStr10 &rhs) const {
 7462    return algo::RnullStr10_Lt(const_cast<algo::RnullStr10&>(*this),const_cast<algo::RnullStr10&>(rhs));
 7463}
 7464
 7465inline bool algo::RnullStr10::operator >(const algo::RnullStr10 &rhs) const {
 7466    return rhs < *this;
 7467}
 7468
 7469inline bool algo::RnullStr10::operator <=(const algo::RnullStr10 &rhs) const {
 7470    return !(rhs < *this);
 7471}
 7472
 7473inline bool algo::RnullStr10::operator >=(const algo::RnullStr10 &rhs) const {
 7474    return !(*this < rhs);
 7475}
 7476inline algo::RnullStr10::RnullStr10() {
 7477    algo::RnullStr10_Init(*this);
 7478}
 7479
 7480
 7481// --- algo.RnullStr10.ch.Getary
 7482// Access string as array of chars
 7483inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr10& parent) {
 7484    int len = ch_N(parent);
 7485    algo::aryptr<char> ret((char*)parent.ch, len);
 7486    return ret;
 7487}
 7488
 7489// --- algo.RnullStr10.ch.HashStrptr
 7490inline u32 algo::RnullStr10_Hash(u32 prev, const algo::strptr &str) {
 7491    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 7492}
 7493
 7494// --- algo.RnullStr10.ch.Init
 7495inline void algo::ch_Init(algo::RnullStr10 &parent) {
 7496    memset(parent.ch, 0, 10);
 7497}
 7498
 7499// --- algo.RnullStr10.ch.Max
 7500// always return constant 10
 7501inline int algo::ch_Max(algo::RnullStr10& parent) {
 7502    (void)parent;
 7503    return 10;
 7504}
 7505
 7506// --- algo.RnullStr10.ch.N
 7507inline int algo::ch_N(const algo::RnullStr10& parent) {
 7508    u64 ret;
 7509    ret = 10;
 7510    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 7511        ret--;
 7512    }
 7513    return int(ret);
 7514}
 7515
 7516// --- algo.RnullStr10.ch.AssignStrptr
 7517// Copy from strptr (operator=)
 7518inline void algo::RnullStr10::operator =(const algo::strptr &str) {
 7519    ch_SetStrptr(*this, str);
 7520}
 7521
 7522// --- algo.RnullStr10.ch.Set
 7523// Copy from same type
 7524// Copy value from RHS.
 7525inline void algo::RnullStr10::operator =(const algo::RnullStr10& parent) {
 7526    memcpy(ch, parent.ch, 10);
 7527}
 7528
 7529// --- algo.RnullStr10.ch.Ctor
 7530inline  algo::RnullStr10::RnullStr10(const algo::RnullStr10 &rhs) {
 7531    operator =(rhs);
 7532}
 7533
 7534// --- algo.RnullStr10.ch.CtorStrptr
 7535inline  algo::RnullStr10::RnullStr10(const algo::strptr &rhs) {
 7536    ch_SetStrptr(*this, rhs);
 7537}
 7538
 7539// --- algo.RnullStr10.ch.Cast
 7540inline algo::RnullStr10::operator algo::strptr () const {
 7541    return ch_Getary(*this);
 7542}
 7543
 7544// --- algo.RnullStr10..Lt
 7545inline bool algo::RnullStr10_Lt(algo::RnullStr10 lhs, algo::RnullStr10 rhs) {
 7546    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 7547}
 7548
 7549// --- algo.RnullStr10..Cmp
 7550inline i32 algo::RnullStr10_Cmp(algo::RnullStr10 lhs, algo::RnullStr10 rhs) {
 7551    i32 retval = 0;
 7552    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 7553    return retval;
 7554}
 7555
 7556// --- algo.RnullStr10..Init
 7557// Set all fields to initial values.
 7558inline void algo::RnullStr10_Init(algo::RnullStr10& parent) {
 7559    memset(parent.ch, 0, 10);
 7560}
 7561
 7562// --- algo.RnullStr10..Eq
 7563inline bool algo::RnullStr10_Eq(algo::RnullStr10 lhs, algo::RnullStr10 rhs) {
 7564    bool retval = true;
 7565    retval = retval
 7566    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 7567    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
 7568    return retval;
 7569}
 7570
 7571// --- algo.RnullStr10..Update
 7572// Set value. Return true if new value is different from old value.
 7573inline bool algo::RnullStr10_Update(algo::RnullStr10 &lhs, algo::RnullStr10 rhs) {
 7574    bool ret = !RnullStr10_Eq(lhs, rhs); // compare values
 7575    if (ret) {
 7576        lhs = rhs; // update
 7577    }
 7578    return ret;
 7579}
 7580
 7581// --- algo.RnullStr10..EqStrptr
 7582inline bool algo::RnullStr10_EqStrptr(algo::RnullStr10 lhs, const algo::strptr& rhs) {
 7583    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 7584}
 7585inline algo::RnullStr100::RnullStr100() {
 7586    algo::RnullStr100_Init(*this);
 7587}
 7588
 7589
 7590// --- algo.RnullStr100.ch.Getary
 7591// Access string as array of chars
 7592inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr100& parent) {
 7593    int len = ch_N(parent);
 7594    algo::aryptr<char> ret((char*)parent.ch, len);
 7595    return ret;
 7596}
 7597
 7598// --- algo.RnullStr100.ch.HashStrptr
 7599inline u32 algo::RnullStr100_Hash(u32 prev, const algo::strptr &str) {
 7600    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 7601}
 7602
 7603// --- algo.RnullStr100.ch.Init
 7604inline void algo::ch_Init(algo::RnullStr100 &parent) {
 7605    memset(parent.ch, 0, 100);
 7606}
 7607
 7608// --- algo.RnullStr100.ch.Max
 7609// always return constant 100
 7610inline int algo::ch_Max(algo::RnullStr100& parent) {
 7611    (void)parent;
 7612    return 100;
 7613}
 7614
 7615// --- algo.RnullStr100.ch.N
 7616inline int algo::ch_N(const algo::RnullStr100& parent) {
 7617    u64 ret;
 7618    ret = 100;
 7619    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 7620        ret--;
 7621    }
 7622    return int(ret);
 7623}
 7624
 7625// --- algo.RnullStr100.ch.AssignStrptr
 7626// Copy from strptr (operator=)
 7627inline void algo::RnullStr100::operator =(const algo::strptr &str) {
 7628    ch_SetStrptr(*this, str);
 7629}
 7630
 7631// --- algo.RnullStr100.ch.Set
 7632// Copy from same type
 7633// Copy value from RHS.
 7634inline void algo::RnullStr100::operator =(const algo::RnullStr100& parent) {
 7635    memcpy(ch, parent.ch, 100);
 7636}
 7637
 7638// --- algo.RnullStr100.ch.Ctor
 7639inline  algo::RnullStr100::RnullStr100(const algo::RnullStr100 &rhs) {
 7640    operator =(rhs);
 7641}
 7642
 7643// --- algo.RnullStr100.ch.CtorStrptr
 7644inline  algo::RnullStr100::RnullStr100(const algo::strptr &rhs) {
 7645    ch_SetStrptr(*this, rhs);
 7646}
 7647
 7648// --- algo.RnullStr100.ch.Cast
 7649inline algo::RnullStr100::operator algo::strptr () const {
 7650    return ch_Getary(*this);
 7651}
 7652
 7653// --- algo.RnullStr100..Lt
 7654inline bool algo::RnullStr100_Lt(algo::RnullStr100& lhs, algo::RnullStr100& rhs) {
 7655    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 7656}
 7657
 7658// --- algo.RnullStr100..Cmp
 7659inline i32 algo::RnullStr100_Cmp(algo::RnullStr100& lhs, algo::RnullStr100& rhs) {
 7660    i32 retval = 0;
 7661    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 7662    return retval;
 7663}
 7664
 7665// --- algo.RnullStr100..Init
 7666// Set all fields to initial values.
 7667inline void algo::RnullStr100_Init(algo::RnullStr100& parent) {
 7668    memset(parent.ch, 0, 100);
 7669}
 7670
 7671// --- algo.RnullStr100..Eq
 7672inline bool algo::RnullStr100_Eq(algo::RnullStr100& lhs, algo::RnullStr100& rhs) {
 7673    bool retval = true;
 7674    retval = retval
 7675    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 7676    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 7677    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
 7678    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
 7679    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
 7680    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
 7681    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
 7682    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
 7683    &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
 7684    &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72)
 7685    &&*(u64*)(lhs.ch+80) == *(u64*)(rhs.ch+80)
 7686    &&*(u64*)(lhs.ch+88) == *(u64*)(rhs.ch+88)
 7687    &&*(u32*)(lhs.ch+96) == *(u32*)(rhs.ch+96);
 7688    return retval;
 7689}
 7690
 7691// --- algo.RnullStr100..Update
 7692// Set value. Return true if new value is different from old value.
 7693inline bool algo::RnullStr100_Update(algo::RnullStr100 &lhs, algo::RnullStr100& rhs) {
 7694    bool ret = !RnullStr100_Eq(lhs, rhs); // compare values
 7695    if (ret) {
 7696        lhs = rhs; // update
 7697    }
 7698    return ret;
 7699}
 7700
 7701// --- algo.RnullStr100..EqStrptr
 7702inline bool algo::RnullStr100_EqStrptr(const algo::RnullStr100& lhs, const algo::strptr& rhs) {
 7703    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 7704}
 7705
 7706inline bool algo::RnullStr1000::operator ==(const algo::RnullStr1000 &rhs) const {
 7707    return algo::RnullStr1000_Eq(const_cast<algo::RnullStr1000&>(*this),const_cast<algo::RnullStr1000&>(rhs));
 7708}
 7709
 7710inline bool algo::RnullStr1000::operator !=(const algo::RnullStr1000 &rhs) const {
 7711    return !algo::RnullStr1000_Eq(const_cast<algo::RnullStr1000&>(*this),const_cast<algo::RnullStr1000&>(rhs));
 7712}
 7713
 7714inline bool algo::RnullStr1000::operator ==(const algo::strptr &rhs) const {
 7715    return algo::RnullStr1000_EqStrptr(const_cast<algo::RnullStr1000&>(*this),rhs);
 7716}
 7717
 7718inline bool algo::RnullStr1000::operator <(const algo::RnullStr1000 &rhs) const {
 7719    return algo::RnullStr1000_Lt(const_cast<algo::RnullStr1000&>(*this),const_cast<algo::RnullStr1000&>(rhs));
 7720}
 7721
 7722inline bool algo::RnullStr1000::operator >(const algo::RnullStr1000 &rhs) const {
 7723    return rhs < *this;
 7724}
 7725
 7726inline bool algo::RnullStr1000::operator <=(const algo::RnullStr1000 &rhs) const {
 7727    return !(rhs < *this);
 7728}
 7729
 7730inline bool algo::RnullStr1000::operator >=(const algo::RnullStr1000 &rhs) const {
 7731    return !(*this < rhs);
 7732}
 7733inline algo::RnullStr1000::RnullStr1000() {
 7734    algo::RnullStr1000_Init(*this);
 7735}
 7736
 7737
 7738// --- algo.RnullStr1000.ch.Getary
 7739// Access string as array of chars
 7740inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr1000& parent) {
 7741    int len = ch_N(parent);
 7742    algo::aryptr<char> ret((char*)parent.ch, len);
 7743    return ret;
 7744}
 7745
 7746// --- algo.RnullStr1000.ch.HashStrptr
 7747inline u32 algo::RnullStr1000_Hash(u32 prev, const algo::strptr &str) {
 7748    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 7749}
 7750
 7751// --- algo.RnullStr1000.ch.Init
 7752inline void algo::ch_Init(algo::RnullStr1000 &parent) {
 7753    memset(parent.ch, 0, 1000);
 7754}
 7755
 7756// --- algo.RnullStr1000.ch.Max
 7757// always return constant 1000
 7758inline int algo::ch_Max(algo::RnullStr1000& parent) {
 7759    (void)parent;
 7760    return 1000;
 7761}
 7762
 7763// --- algo.RnullStr1000.ch.N
 7764inline int algo::ch_N(const algo::RnullStr1000& parent) {
 7765    u64 ret;
 7766    ret = 1000;
 7767    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 7768        ret--;
 7769    }
 7770    return int(ret);
 7771}
 7772
 7773// --- algo.RnullStr1000.ch.AssignStrptr
 7774// Copy from strptr (operator=)
 7775inline void algo::RnullStr1000::operator =(const algo::strptr &str) {
 7776    ch_SetStrptr(*this, str);
 7777}
 7778
 7779// --- algo.RnullStr1000.ch.Set
 7780// Copy from same type
 7781// Copy value from RHS.
 7782inline void algo::RnullStr1000::operator =(const algo::RnullStr1000& parent) {
 7783    memcpy(ch, parent.ch, 1000);
 7784}
 7785
 7786// --- algo.RnullStr1000.ch.Ctor
 7787inline  algo::RnullStr1000::RnullStr1000(const algo::RnullStr1000 &rhs) {
 7788    operator =(rhs);
 7789}
 7790
 7791// --- algo.RnullStr1000.ch.CtorStrptr
 7792inline  algo::RnullStr1000::RnullStr1000(const algo::strptr &rhs) {
 7793    ch_SetStrptr(*this, rhs);
 7794}
 7795
 7796// --- algo.RnullStr1000.ch.Cast
 7797inline algo::RnullStr1000::operator algo::strptr () const {
 7798    return ch_Getary(*this);
 7799}
 7800
 7801// --- algo.RnullStr1000..Lt
 7802inline bool algo::RnullStr1000_Lt(algo::RnullStr1000& lhs, algo::RnullStr1000& rhs) {
 7803    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 7804}
 7805
 7806// --- algo.RnullStr1000..Cmp
 7807inline i32 algo::RnullStr1000_Cmp(algo::RnullStr1000& lhs, algo::RnullStr1000& rhs) {
 7808    i32 retval = 0;
 7809    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 7810    return retval;
 7811}
 7812
 7813// --- algo.RnullStr1000..Init
 7814// Set all fields to initial values.
 7815inline void algo::RnullStr1000_Init(algo::RnullStr1000& parent) {
 7816    memset(parent.ch, 0, 1000);
 7817}
 7818
 7819// --- algo.RnullStr1000..Eq
 7820inline bool algo::RnullStr1000_Eq(algo::RnullStr1000& lhs, algo::RnullStr1000& rhs) {
 7821    bool retval = true;
 7822    for (int i=0; i<125 && retval; i++) {
 7823        retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
 7824    }
 7825    return retval;
 7826}
 7827
 7828// --- algo.RnullStr1000..Update
 7829// Set value. Return true if new value is different from old value.
 7830inline bool algo::RnullStr1000_Update(algo::RnullStr1000 &lhs, algo::RnullStr1000& rhs) {
 7831    bool ret = !RnullStr1000_Eq(lhs, rhs); // compare values
 7832    if (ret) {
 7833        lhs = rhs; // update
 7834    }
 7835    return ret;
 7836}
 7837
 7838// --- algo.RnullStr1000..EqStrptr
 7839inline bool algo::RnullStr1000_EqStrptr(const algo::RnullStr1000& lhs, const algo::strptr& rhs) {
 7840    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 7841}
 7842
 7843inline bool algo::RnullStr11::operator ==(const algo::RnullStr11 &rhs) const {
 7844    return algo::RnullStr11_Eq(const_cast<algo::RnullStr11&>(*this),const_cast<algo::RnullStr11&>(rhs));
 7845}
 7846
 7847inline bool algo::RnullStr11::operator !=(const algo::RnullStr11 &rhs) const {
 7848    return !algo::RnullStr11_Eq(const_cast<algo::RnullStr11&>(*this),const_cast<algo::RnullStr11&>(rhs));
 7849}
 7850
 7851inline bool algo::RnullStr11::operator ==(const algo::strptr &rhs) const {
 7852    return algo::RnullStr11_EqStrptr(const_cast<algo::RnullStr11&>(*this),rhs);
 7853}
 7854
 7855inline bool algo::RnullStr11::operator <(const algo::RnullStr11 &rhs) const {
 7856    return algo::RnullStr11_Lt(const_cast<algo::RnullStr11&>(*this),const_cast<algo::RnullStr11&>(rhs));
 7857}
 7858
 7859inline bool algo::RnullStr11::operator >(const algo::RnullStr11 &rhs) const {
 7860    return rhs < *this;
 7861}
 7862
 7863inline bool algo::RnullStr11::operator <=(const algo::RnullStr11 &rhs) const {
 7864    return !(rhs < *this);
 7865}
 7866
 7867inline bool algo::RnullStr11::operator >=(const algo::RnullStr11 &rhs) const {
 7868    return !(*this < rhs);
 7869}
 7870inline algo::RnullStr11::RnullStr11() {
 7871    algo::RnullStr11_Init(*this);
 7872}
 7873
 7874
 7875// --- algo.RnullStr11.ch.Getary
 7876// Access string as array of chars
 7877inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr11& parent) {
 7878    int len = ch_N(parent);
 7879    algo::aryptr<char> ret((char*)parent.ch, len);
 7880    return ret;
 7881}
 7882
 7883// --- algo.RnullStr11.ch.HashStrptr
 7884inline u32 algo::RnullStr11_Hash(u32 prev, const algo::strptr &str) {
 7885    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 7886}
 7887
 7888// --- algo.RnullStr11.ch.Init
 7889inline void algo::ch_Init(algo::RnullStr11 &parent) {
 7890    memset(parent.ch, 0, 11);
 7891}
 7892
 7893// --- algo.RnullStr11.ch.Max
 7894// always return constant 11
 7895inline int algo::ch_Max(algo::RnullStr11& parent) {
 7896    (void)parent;
 7897    return 11;
 7898}
 7899
 7900// --- algo.RnullStr11.ch.N
 7901inline int algo::ch_N(const algo::RnullStr11& parent) {
 7902    u64 ret;
 7903    ret = 11;
 7904    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 7905        ret--;
 7906    }
 7907    return int(ret);
 7908}
 7909
 7910// --- algo.RnullStr11.ch.AssignStrptr
 7911// Copy from strptr (operator=)
 7912inline void algo::RnullStr11::operator =(const algo::strptr &str) {
 7913    ch_SetStrptr(*this, str);
 7914}
 7915
 7916// --- algo.RnullStr11.ch.Set
 7917// Copy from same type
 7918// Copy value from RHS.
 7919inline void algo::RnullStr11::operator =(const algo::RnullStr11& parent) {
 7920    memcpy(ch, parent.ch, 11);
 7921}
 7922
 7923// --- algo.RnullStr11.ch.Ctor
 7924inline  algo::RnullStr11::RnullStr11(const algo::RnullStr11 &rhs) {
 7925    operator =(rhs);
 7926}
 7927
 7928// --- algo.RnullStr11.ch.CtorStrptr
 7929inline  algo::RnullStr11::RnullStr11(const algo::strptr &rhs) {
 7930    ch_SetStrptr(*this, rhs);
 7931}
 7932
 7933// --- algo.RnullStr11.ch.Cast
 7934inline algo::RnullStr11::operator algo::strptr () const {
 7935    return ch_Getary(*this);
 7936}
 7937
 7938// --- algo.RnullStr11..Lt
 7939inline bool algo::RnullStr11_Lt(algo::RnullStr11& lhs, algo::RnullStr11& rhs) {
 7940    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 7941}
 7942
 7943// --- algo.RnullStr11..Cmp
 7944inline i32 algo::RnullStr11_Cmp(algo::RnullStr11& lhs, algo::RnullStr11& rhs) {
 7945    i32 retval = 0;
 7946    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 7947    return retval;
 7948}
 7949
 7950// --- algo.RnullStr11..Init
 7951// Set all fields to initial values.
 7952inline void algo::RnullStr11_Init(algo::RnullStr11& parent) {
 7953    memset(parent.ch, 0, 11);
 7954}
 7955
 7956// --- algo.RnullStr11..Eq
 7957inline bool algo::RnullStr11_Eq(algo::RnullStr11& lhs, algo::RnullStr11& rhs) {
 7958    bool retval = true;
 7959    retval = retval
 7960    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 7961    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8)
 7962    &&*(u8*)(lhs.ch+10) == *(u8*)(rhs.ch+10);
 7963    return retval;
 7964}
 7965
 7966// --- algo.RnullStr11..Update
 7967// Set value. Return true if new value is different from old value.
 7968inline bool algo::RnullStr11_Update(algo::RnullStr11 &lhs, algo::RnullStr11& rhs) {
 7969    bool ret = !RnullStr11_Eq(lhs, rhs); // compare values
 7970    if (ret) {
 7971        lhs = rhs; // update
 7972    }
 7973    return ret;
 7974}
 7975
 7976// --- algo.RnullStr11..EqStrptr
 7977inline bool algo::RnullStr11_EqStrptr(const algo::RnullStr11& lhs, const algo::strptr& rhs) {
 7978    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 7979}
 7980
 7981inline bool algo::RnullStr12::operator ==(const algo::RnullStr12 &rhs) const {
 7982    return algo::RnullStr12_Eq(const_cast<algo::RnullStr12&>(*this),const_cast<algo::RnullStr12&>(rhs));
 7983}
 7984
 7985inline bool algo::RnullStr12::operator !=(const algo::RnullStr12 &rhs) const {
 7986    return !algo::RnullStr12_Eq(const_cast<algo::RnullStr12&>(*this),const_cast<algo::RnullStr12&>(rhs));
 7987}
 7988
 7989inline bool algo::RnullStr12::operator ==(const algo::strptr &rhs) const {
 7990    return algo::RnullStr12_EqStrptr(const_cast<algo::RnullStr12&>(*this),rhs);
 7991}
 7992
 7993inline bool algo::RnullStr12::operator <(const algo::RnullStr12 &rhs) const {
 7994    return algo::RnullStr12_Lt(const_cast<algo::RnullStr12&>(*this),const_cast<algo::RnullStr12&>(rhs));
 7995}
 7996
 7997inline bool algo::RnullStr12::operator >(const algo::RnullStr12 &rhs) const {
 7998    return rhs < *this;
 7999}
 8000
 8001inline bool algo::RnullStr12::operator <=(const algo::RnullStr12 &rhs) const {
 8002    return !(rhs < *this);
 8003}
 8004
 8005inline bool algo::RnullStr12::operator >=(const algo::RnullStr12 &rhs) const {
 8006    return !(*this < rhs);
 8007}
 8008inline algo::RnullStr12::RnullStr12() {
 8009    algo::RnullStr12_Init(*this);
 8010}
 8011
 8012
 8013// --- algo.RnullStr12.ch.Getary
 8014// Access string as array of chars
 8015inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr12& parent) {
 8016    int len = ch_N(parent);
 8017    algo::aryptr<char> ret((char*)parent.ch, len);
 8018    return ret;
 8019}
 8020
 8021// --- algo.RnullStr12.ch.HashStrptr
 8022inline u32 algo::RnullStr12_Hash(u32 prev, const algo::strptr &str) {
 8023    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8024}
 8025
 8026// --- algo.RnullStr12.ch.Init
 8027inline void algo::ch_Init(algo::RnullStr12 &parent) {
 8028    memset(parent.ch, 0, 12);
 8029}
 8030
 8031// --- algo.RnullStr12.ch.Max
 8032// always return constant 12
 8033inline int algo::ch_Max(algo::RnullStr12& parent) {
 8034    (void)parent;
 8035    return 12;
 8036}
 8037
 8038// --- algo.RnullStr12.ch.N
 8039inline int algo::ch_N(const algo::RnullStr12& parent) {
 8040    u64 ret;
 8041    ret = 12;
 8042    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8043        ret--;
 8044    }
 8045    return int(ret);
 8046}
 8047
 8048// --- algo.RnullStr12.ch.AssignStrptr
 8049// Copy from strptr (operator=)
 8050inline void algo::RnullStr12::operator =(const algo::strptr &str) {
 8051    ch_SetStrptr(*this, str);
 8052}
 8053
 8054// --- algo.RnullStr12.ch.Set
 8055// Copy from same type
 8056// Copy value from RHS.
 8057inline void algo::RnullStr12::operator =(const algo::RnullStr12& parent) {
 8058    memcpy(ch, parent.ch, 12);
 8059}
 8060
 8061// --- algo.RnullStr12.ch.Ctor
 8062inline  algo::RnullStr12::RnullStr12(const algo::RnullStr12 &rhs) {
 8063    operator =(rhs);
 8064}
 8065
 8066// --- algo.RnullStr12.ch.CtorStrptr
 8067inline  algo::RnullStr12::RnullStr12(const algo::strptr &rhs) {
 8068    ch_SetStrptr(*this, rhs);
 8069}
 8070
 8071// --- algo.RnullStr12.ch.Cast
 8072inline algo::RnullStr12::operator algo::strptr () const {
 8073    return ch_Getary(*this);
 8074}
 8075
 8076// --- algo.RnullStr12..Lt
 8077inline bool algo::RnullStr12_Lt(algo::RnullStr12& lhs, algo::RnullStr12& rhs) {
 8078    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8079}
 8080
 8081// --- algo.RnullStr12..Cmp
 8082inline i32 algo::RnullStr12_Cmp(algo::RnullStr12& lhs, algo::RnullStr12& rhs) {
 8083    i32 retval = 0;
 8084    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8085    return retval;
 8086}
 8087
 8088// --- algo.RnullStr12..Init
 8089// Set all fields to initial values.
 8090inline void algo::RnullStr12_Init(algo::RnullStr12& parent) {
 8091    memset(parent.ch, 0, 12);
 8092}
 8093
 8094// --- algo.RnullStr12..Eq
 8095inline bool algo::RnullStr12_Eq(algo::RnullStr12& lhs, algo::RnullStr12& rhs) {
 8096    bool retval = true;
 8097    retval = retval
 8098    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 8099    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
 8100    return retval;
 8101}
 8102
 8103// --- algo.RnullStr12..Update
 8104// Set value. Return true if new value is different from old value.
 8105inline bool algo::RnullStr12_Update(algo::RnullStr12 &lhs, algo::RnullStr12& rhs) {
 8106    bool ret = !RnullStr12_Eq(lhs, rhs); // compare values
 8107    if (ret) {
 8108        lhs = rhs; // update
 8109    }
 8110    return ret;
 8111}
 8112
 8113// --- algo.RnullStr12..EqStrptr
 8114inline bool algo::RnullStr12_EqStrptr(const algo::RnullStr12& lhs, const algo::strptr& rhs) {
 8115    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8116}
 8117
 8118inline bool algo::RnullStr129::operator ==(const algo::RnullStr129 &rhs) const {
 8119    return algo::RnullStr129_Eq(const_cast<algo::RnullStr129&>(*this),const_cast<algo::RnullStr129&>(rhs));
 8120}
 8121
 8122inline bool algo::RnullStr129::operator !=(const algo::RnullStr129 &rhs) const {
 8123    return !algo::RnullStr129_Eq(const_cast<algo::RnullStr129&>(*this),const_cast<algo::RnullStr129&>(rhs));
 8124}
 8125
 8126inline bool algo::RnullStr129::operator ==(const algo::strptr &rhs) const {
 8127    return algo::RnullStr129_EqStrptr(const_cast<algo::RnullStr129&>(*this),rhs);
 8128}
 8129
 8130inline bool algo::RnullStr129::operator <(const algo::RnullStr129 &rhs) const {
 8131    return algo::RnullStr129_Lt(const_cast<algo::RnullStr129&>(*this),const_cast<algo::RnullStr129&>(rhs));
 8132}
 8133
 8134inline bool algo::RnullStr129::operator >(const algo::RnullStr129 &rhs) const {
 8135    return rhs < *this;
 8136}
 8137
 8138inline bool algo::RnullStr129::operator <=(const algo::RnullStr129 &rhs) const {
 8139    return !(rhs < *this);
 8140}
 8141
 8142inline bool algo::RnullStr129::operator >=(const algo::RnullStr129 &rhs) const {
 8143    return !(*this < rhs);
 8144}
 8145inline algo::RnullStr129::RnullStr129() {
 8146    algo::RnullStr129_Init(*this);
 8147}
 8148
 8149
 8150// --- algo.RnullStr129.ch.Getary
 8151// Access string as array of chars
 8152inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr129& parent) {
 8153    int len = ch_N(parent);
 8154    algo::aryptr<char> ret((char*)parent.ch, len);
 8155    return ret;
 8156}
 8157
 8158// --- algo.RnullStr129.ch.HashStrptr
 8159inline u32 algo::RnullStr129_Hash(u32 prev, const algo::strptr &str) {
 8160    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8161}
 8162
 8163// --- algo.RnullStr129.ch.Init
 8164inline void algo::ch_Init(algo::RnullStr129 &parent) {
 8165    memset(parent.ch, 0, 129);
 8166}
 8167
 8168// --- algo.RnullStr129.ch.Max
 8169// always return constant 129
 8170inline int algo::ch_Max(algo::RnullStr129& parent) {
 8171    (void)parent;
 8172    return 129;
 8173}
 8174
 8175// --- algo.RnullStr129.ch.N
 8176inline int algo::ch_N(const algo::RnullStr129& parent) {
 8177    u64 ret;
 8178    ret = 129;
 8179    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8180        ret--;
 8181    }
 8182    return int(ret);
 8183}
 8184
 8185// --- algo.RnullStr129.ch.AssignStrptr
 8186// Copy from strptr (operator=)
 8187inline void algo::RnullStr129::operator =(const algo::strptr &str) {
 8188    ch_SetStrptr(*this, str);
 8189}
 8190
 8191// --- algo.RnullStr129.ch.Set
 8192// Copy from same type
 8193// Copy value from RHS.
 8194inline void algo::RnullStr129::operator =(const algo::RnullStr129& parent) {
 8195    memcpy(ch, parent.ch, 129);
 8196}
 8197
 8198// --- algo.RnullStr129.ch.Ctor
 8199inline  algo::RnullStr129::RnullStr129(const algo::RnullStr129 &rhs) {
 8200    operator =(rhs);
 8201}
 8202
 8203// --- algo.RnullStr129.ch.CtorStrptr
 8204inline  algo::RnullStr129::RnullStr129(const algo::strptr &rhs) {
 8205    ch_SetStrptr(*this, rhs);
 8206}
 8207
 8208// --- algo.RnullStr129.ch.Cast
 8209inline algo::RnullStr129::operator algo::strptr () const {
 8210    return ch_Getary(*this);
 8211}
 8212
 8213// --- algo.RnullStr129..Lt
 8214inline bool algo::RnullStr129_Lt(algo::RnullStr129& lhs, algo::RnullStr129& rhs) {
 8215    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8216}
 8217
 8218// --- algo.RnullStr129..Cmp
 8219inline i32 algo::RnullStr129_Cmp(algo::RnullStr129& lhs, algo::RnullStr129& rhs) {
 8220    i32 retval = 0;
 8221    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8222    return retval;
 8223}
 8224
 8225// --- algo.RnullStr129..Init
 8226// Set all fields to initial values.
 8227inline void algo::RnullStr129_Init(algo::RnullStr129& parent) {
 8228    memset(parent.ch, 0, 129);
 8229}
 8230
 8231// --- algo.RnullStr129..Eq
 8232inline bool algo::RnullStr129_Eq(algo::RnullStr129& lhs, algo::RnullStr129& rhs) {
 8233    bool retval = true;
 8234    for (int i=0; i<16 && retval; i++) {
 8235        retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
 8236    }
 8237    retval = retval
 8238    &&*(u8*)(lhs.ch+128) == *(u8*)(rhs.ch+128);
 8239    return retval;
 8240}
 8241
 8242// --- algo.RnullStr129..Update
 8243// Set value. Return true if new value is different from old value.
 8244inline bool algo::RnullStr129_Update(algo::RnullStr129 &lhs, algo::RnullStr129& rhs) {
 8245    bool ret = !RnullStr129_Eq(lhs, rhs); // compare values
 8246    if (ret) {
 8247        lhs = rhs; // update
 8248    }
 8249    return ret;
 8250}
 8251
 8252// --- algo.RnullStr129..EqStrptr
 8253inline bool algo::RnullStr129_EqStrptr(const algo::RnullStr129& lhs, const algo::strptr& rhs) {
 8254    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8255}
 8256
 8257inline bool algo::RnullStr13::operator ==(const algo::RnullStr13 &rhs) const {
 8258    return algo::RnullStr13_Eq(const_cast<algo::RnullStr13&>(*this),const_cast<algo::RnullStr13&>(rhs));
 8259}
 8260
 8261inline bool algo::RnullStr13::operator !=(const algo::RnullStr13 &rhs) const {
 8262    return !algo::RnullStr13_Eq(const_cast<algo::RnullStr13&>(*this),const_cast<algo::RnullStr13&>(rhs));
 8263}
 8264
 8265inline bool algo::RnullStr13::operator ==(const algo::strptr &rhs) const {
 8266    return algo::RnullStr13_EqStrptr(const_cast<algo::RnullStr13&>(*this),rhs);
 8267}
 8268
 8269inline bool algo::RnullStr13::operator <(const algo::RnullStr13 &rhs) const {
 8270    return algo::RnullStr13_Lt(const_cast<algo::RnullStr13&>(*this),const_cast<algo::RnullStr13&>(rhs));
 8271}
 8272
 8273inline bool algo::RnullStr13::operator >(const algo::RnullStr13 &rhs) const {
 8274    return rhs < *this;
 8275}
 8276
 8277inline bool algo::RnullStr13::operator <=(const algo::RnullStr13 &rhs) const {
 8278    return !(rhs < *this);
 8279}
 8280
 8281inline bool algo::RnullStr13::operator >=(const algo::RnullStr13 &rhs) const {
 8282    return !(*this < rhs);
 8283}
 8284inline algo::RnullStr13::RnullStr13() {
 8285    algo::RnullStr13_Init(*this);
 8286}
 8287
 8288
 8289// --- algo.RnullStr13.ch.Getary
 8290// Access string as array of chars
 8291inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr13& parent) {
 8292    int len = ch_N(parent);
 8293    algo::aryptr<char> ret((char*)parent.ch, len);
 8294    return ret;
 8295}
 8296
 8297// --- algo.RnullStr13.ch.HashStrptr
 8298inline u32 algo::RnullStr13_Hash(u32 prev, const algo::strptr &str) {
 8299    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8300}
 8301
 8302// --- algo.RnullStr13.ch.Init
 8303inline void algo::ch_Init(algo::RnullStr13 &parent) {
 8304    memset(parent.ch, 0, 13);
 8305}
 8306
 8307// --- algo.RnullStr13.ch.Max
 8308// always return constant 13
 8309inline int algo::ch_Max(algo::RnullStr13& parent) {
 8310    (void)parent;
 8311    return 13;
 8312}
 8313
 8314// --- algo.RnullStr13.ch.N
 8315inline int algo::ch_N(const algo::RnullStr13& parent) {
 8316    u64 ret;
 8317    ret = 13;
 8318    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8319        ret--;
 8320    }
 8321    return int(ret);
 8322}
 8323
 8324// --- algo.RnullStr13.ch.AssignStrptr
 8325// Copy from strptr (operator=)
 8326inline void algo::RnullStr13::operator =(const algo::strptr &str) {
 8327    ch_SetStrptr(*this, str);
 8328}
 8329
 8330// --- algo.RnullStr13.ch.Set
 8331// Copy from same type
 8332// Copy value from RHS.
 8333inline void algo::RnullStr13::operator =(const algo::RnullStr13& parent) {
 8334    memcpy(ch, parent.ch, 13);
 8335}
 8336
 8337// --- algo.RnullStr13.ch.Ctor
 8338inline  algo::RnullStr13::RnullStr13(const algo::RnullStr13 &rhs) {
 8339    operator =(rhs);
 8340}
 8341
 8342// --- algo.RnullStr13.ch.CtorStrptr
 8343inline  algo::RnullStr13::RnullStr13(const algo::strptr &rhs) {
 8344    ch_SetStrptr(*this, rhs);
 8345}
 8346
 8347// --- algo.RnullStr13.ch.Cast
 8348inline algo::RnullStr13::operator algo::strptr () const {
 8349    return ch_Getary(*this);
 8350}
 8351
 8352// --- algo.RnullStr13..Lt
 8353inline bool algo::RnullStr13_Lt(algo::RnullStr13& lhs, algo::RnullStr13& rhs) {
 8354    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8355}
 8356
 8357// --- algo.RnullStr13..Cmp
 8358inline i32 algo::RnullStr13_Cmp(algo::RnullStr13& lhs, algo::RnullStr13& rhs) {
 8359    i32 retval = 0;
 8360    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8361    return retval;
 8362}
 8363
 8364// --- algo.RnullStr13..Init
 8365// Set all fields to initial values.
 8366inline void algo::RnullStr13_Init(algo::RnullStr13& parent) {
 8367    memset(parent.ch, 0, 13);
 8368}
 8369
 8370// --- algo.RnullStr13..Eq
 8371inline bool algo::RnullStr13_Eq(algo::RnullStr13& lhs, algo::RnullStr13& rhs) {
 8372    bool retval = true;
 8373    retval = retval
 8374    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 8375    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
 8376    &&*(u8*)(lhs.ch+12) == *(u8*)(rhs.ch+12);
 8377    return retval;
 8378}
 8379
 8380// --- algo.RnullStr13..Update
 8381// Set value. Return true if new value is different from old value.
 8382inline bool algo::RnullStr13_Update(algo::RnullStr13 &lhs, algo::RnullStr13& rhs) {
 8383    bool ret = !RnullStr13_Eq(lhs, rhs); // compare values
 8384    if (ret) {
 8385        lhs = rhs; // update
 8386    }
 8387    return ret;
 8388}
 8389
 8390// --- algo.RnullStr13..EqStrptr
 8391inline bool algo::RnullStr13_EqStrptr(const algo::RnullStr13& lhs, const algo::strptr& rhs) {
 8392    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8393}
 8394
 8395inline bool algo::RnullStr14::operator ==(const algo::RnullStr14 &rhs) const {
 8396    return algo::RnullStr14_Eq(const_cast<algo::RnullStr14&>(*this),const_cast<algo::RnullStr14&>(rhs));
 8397}
 8398
 8399inline bool algo::RnullStr14::operator !=(const algo::RnullStr14 &rhs) const {
 8400    return !algo::RnullStr14_Eq(const_cast<algo::RnullStr14&>(*this),const_cast<algo::RnullStr14&>(rhs));
 8401}
 8402
 8403inline bool algo::RnullStr14::operator ==(const algo::strptr &rhs) const {
 8404    return algo::RnullStr14_EqStrptr(const_cast<algo::RnullStr14&>(*this),rhs);
 8405}
 8406
 8407inline bool algo::RnullStr14::operator <(const algo::RnullStr14 &rhs) const {
 8408    return algo::RnullStr14_Lt(const_cast<algo::RnullStr14&>(*this),const_cast<algo::RnullStr14&>(rhs));
 8409}
 8410
 8411inline bool algo::RnullStr14::operator >(const algo::RnullStr14 &rhs) const {
 8412    return rhs < *this;
 8413}
 8414
 8415inline bool algo::RnullStr14::operator <=(const algo::RnullStr14 &rhs) const {
 8416    return !(rhs < *this);
 8417}
 8418
 8419inline bool algo::RnullStr14::operator >=(const algo::RnullStr14 &rhs) const {
 8420    return !(*this < rhs);
 8421}
 8422inline algo::RnullStr14::RnullStr14() {
 8423    algo::RnullStr14_Init(*this);
 8424}
 8425
 8426
 8427// --- algo.RnullStr14.ch.Getary
 8428// Access string as array of chars
 8429inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr14& parent) {
 8430    int len = ch_N(parent);
 8431    algo::aryptr<char> ret((char*)parent.ch, len);
 8432    return ret;
 8433}
 8434
 8435// --- algo.RnullStr14.ch.HashStrptr
 8436inline u32 algo::RnullStr14_Hash(u32 prev, const algo::strptr &str) {
 8437    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8438}
 8439
 8440// --- algo.RnullStr14.ch.Init
 8441inline void algo::ch_Init(algo::RnullStr14 &parent) {
 8442    memset(parent.ch, 0, 14);
 8443}
 8444
 8445// --- algo.RnullStr14.ch.Max
 8446// always return constant 14
 8447inline int algo::ch_Max(algo::RnullStr14& parent) {
 8448    (void)parent;
 8449    return 14;
 8450}
 8451
 8452// --- algo.RnullStr14.ch.N
 8453inline int algo::ch_N(const algo::RnullStr14& parent) {
 8454    u64 ret;
 8455    ret = 14;
 8456    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8457        ret--;
 8458    }
 8459    return int(ret);
 8460}
 8461
 8462// --- algo.RnullStr14.ch.AssignStrptr
 8463// Copy from strptr (operator=)
 8464inline void algo::RnullStr14::operator =(const algo::strptr &str) {
 8465    ch_SetStrptr(*this, str);
 8466}
 8467
 8468// --- algo.RnullStr14.ch.Set
 8469// Copy from same type
 8470// Copy value from RHS.
 8471inline void algo::RnullStr14::operator =(const algo::RnullStr14& parent) {
 8472    memcpy(ch, parent.ch, 14);
 8473}
 8474
 8475// --- algo.RnullStr14.ch.Ctor
 8476inline  algo::RnullStr14::RnullStr14(const algo::RnullStr14 &rhs) {
 8477    operator =(rhs);
 8478}
 8479
 8480// --- algo.RnullStr14.ch.CtorStrptr
 8481inline  algo::RnullStr14::RnullStr14(const algo::strptr &rhs) {
 8482    ch_SetStrptr(*this, rhs);
 8483}
 8484
 8485// --- algo.RnullStr14.ch.Cast
 8486inline algo::RnullStr14::operator algo::strptr () const {
 8487    return ch_Getary(*this);
 8488}
 8489
 8490// --- algo.RnullStr14..Lt
 8491inline bool algo::RnullStr14_Lt(algo::RnullStr14& lhs, algo::RnullStr14& rhs) {
 8492    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8493}
 8494
 8495// --- algo.RnullStr14..Cmp
 8496inline i32 algo::RnullStr14_Cmp(algo::RnullStr14& lhs, algo::RnullStr14& rhs) {
 8497    i32 retval = 0;
 8498    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8499    return retval;
 8500}
 8501
 8502// --- algo.RnullStr14..Init
 8503// Set all fields to initial values.
 8504inline void algo::RnullStr14_Init(algo::RnullStr14& parent) {
 8505    memset(parent.ch, 0, 14);
 8506}
 8507
 8508// --- algo.RnullStr14..Eq
 8509inline bool algo::RnullStr14_Eq(algo::RnullStr14& lhs, algo::RnullStr14& rhs) {
 8510    bool retval = true;
 8511    retval = retval
 8512    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 8513    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
 8514    &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12);
 8515    return retval;
 8516}
 8517
 8518// --- algo.RnullStr14..Update
 8519// Set value. Return true if new value is different from old value.
 8520inline bool algo::RnullStr14_Update(algo::RnullStr14 &lhs, algo::RnullStr14& rhs) {
 8521    bool ret = !RnullStr14_Eq(lhs, rhs); // compare values
 8522    if (ret) {
 8523        lhs = rhs; // update
 8524    }
 8525    return ret;
 8526}
 8527
 8528// --- algo.RnullStr14..EqStrptr
 8529inline bool algo::RnullStr14_EqStrptr(const algo::RnullStr14& lhs, const algo::strptr& rhs) {
 8530    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8531}
 8532
 8533inline bool algo::RnullStr15::operator ==(const algo::RnullStr15 &rhs) const {
 8534    return algo::RnullStr15_Eq(const_cast<algo::RnullStr15&>(*this),const_cast<algo::RnullStr15&>(rhs));
 8535}
 8536
 8537inline bool algo::RnullStr15::operator !=(const algo::RnullStr15 &rhs) const {
 8538    return !algo::RnullStr15_Eq(const_cast<algo::RnullStr15&>(*this),const_cast<algo::RnullStr15&>(rhs));
 8539}
 8540
 8541inline bool algo::RnullStr15::operator ==(const algo::strptr &rhs) const {
 8542    return algo::RnullStr15_EqStrptr(const_cast<algo::RnullStr15&>(*this),rhs);
 8543}
 8544
 8545inline bool algo::RnullStr15::operator <(const algo::RnullStr15 &rhs) const {
 8546    return algo::RnullStr15_Lt(const_cast<algo::RnullStr15&>(*this),const_cast<algo::RnullStr15&>(rhs));
 8547}
 8548
 8549inline bool algo::RnullStr15::operator >(const algo::RnullStr15 &rhs) const {
 8550    return rhs < *this;
 8551}
 8552
 8553inline bool algo::RnullStr15::operator <=(const algo::RnullStr15 &rhs) const {
 8554    return !(rhs < *this);
 8555}
 8556
 8557inline bool algo::RnullStr15::operator >=(const algo::RnullStr15 &rhs) const {
 8558    return !(*this < rhs);
 8559}
 8560inline algo::RnullStr15::RnullStr15() {
 8561    algo::RnullStr15_Init(*this);
 8562}
 8563
 8564
 8565// --- algo.RnullStr15.ch.Getary
 8566// Access string as array of chars
 8567inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr15& parent) {
 8568    int len = ch_N(parent);
 8569    algo::aryptr<char> ret((char*)parent.ch, len);
 8570    return ret;
 8571}
 8572
 8573// --- algo.RnullStr15.ch.HashStrptr
 8574inline u32 algo::RnullStr15_Hash(u32 prev, const algo::strptr &str) {
 8575    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8576}
 8577
 8578// --- algo.RnullStr15.ch.Init
 8579inline void algo::ch_Init(algo::RnullStr15 &parent) {
 8580    memset(parent.ch, 0, 15);
 8581}
 8582
 8583// --- algo.RnullStr15.ch.Max
 8584// always return constant 15
 8585inline int algo::ch_Max(algo::RnullStr15& parent) {
 8586    (void)parent;
 8587    return 15;
 8588}
 8589
 8590// --- algo.RnullStr15.ch.N
 8591inline int algo::ch_N(const algo::RnullStr15& parent) {
 8592    u64 ret;
 8593    ret = 15;
 8594    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8595        ret--;
 8596    }
 8597    return int(ret);
 8598}
 8599
 8600// --- algo.RnullStr15.ch.AssignStrptr
 8601// Copy from strptr (operator=)
 8602inline void algo::RnullStr15::operator =(const algo::strptr &str) {
 8603    ch_SetStrptr(*this, str);
 8604}
 8605
 8606// --- algo.RnullStr15.ch.Set
 8607// Copy from same type
 8608// Copy value from RHS.
 8609inline void algo::RnullStr15::operator =(const algo::RnullStr15& parent) {
 8610    memcpy(ch, parent.ch, 15);
 8611}
 8612
 8613// --- algo.RnullStr15.ch.Ctor
 8614inline  algo::RnullStr15::RnullStr15(const algo::RnullStr15 &rhs) {
 8615    operator =(rhs);
 8616}
 8617
 8618// --- algo.RnullStr15.ch.CtorStrptr
 8619inline  algo::RnullStr15::RnullStr15(const algo::strptr &rhs) {
 8620    ch_SetStrptr(*this, rhs);
 8621}
 8622
 8623// --- algo.RnullStr15.ch.Cast
 8624inline algo::RnullStr15::operator algo::strptr () const {
 8625    return ch_Getary(*this);
 8626}
 8627
 8628// --- algo.RnullStr15..Lt
 8629inline bool algo::RnullStr15_Lt(algo::RnullStr15& lhs, algo::RnullStr15& rhs) {
 8630    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8631}
 8632
 8633// --- algo.RnullStr15..Cmp
 8634inline i32 algo::RnullStr15_Cmp(algo::RnullStr15& lhs, algo::RnullStr15& rhs) {
 8635    i32 retval = 0;
 8636    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8637    return retval;
 8638}
 8639
 8640// --- algo.RnullStr15..Init
 8641// Set all fields to initial values.
 8642inline void algo::RnullStr15_Init(algo::RnullStr15& parent) {
 8643    memset(parent.ch, 0, 15);
 8644}
 8645
 8646// --- algo.RnullStr15..Eq
 8647inline bool algo::RnullStr15_Eq(algo::RnullStr15& lhs, algo::RnullStr15& rhs) {
 8648    bool retval = true;
 8649    retval = retval
 8650    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 8651    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
 8652    &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12)
 8653    &&*(u8*)(lhs.ch+14) == *(u8*)(rhs.ch+14);
 8654    return retval;
 8655}
 8656
 8657// --- algo.RnullStr15..Update
 8658// Set value. Return true if new value is different from old value.
 8659inline bool algo::RnullStr15_Update(algo::RnullStr15 &lhs, algo::RnullStr15& rhs) {
 8660    bool ret = !RnullStr15_Eq(lhs, rhs); // compare values
 8661    if (ret) {
 8662        lhs = rhs; // update
 8663    }
 8664    return ret;
 8665}
 8666
 8667// --- algo.RnullStr15..EqStrptr
 8668inline bool algo::RnullStr15_EqStrptr(const algo::RnullStr15& lhs, const algo::strptr& rhs) {
 8669    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8670}
 8671
 8672inline bool algo::RnullStr151::operator ==(const algo::RnullStr151 &rhs) const {
 8673    return algo::RnullStr151_Eq(const_cast<algo::RnullStr151&>(*this),const_cast<algo::RnullStr151&>(rhs));
 8674}
 8675
 8676inline bool algo::RnullStr151::operator !=(const algo::RnullStr151 &rhs) const {
 8677    return !algo::RnullStr151_Eq(const_cast<algo::RnullStr151&>(*this),const_cast<algo::RnullStr151&>(rhs));
 8678}
 8679
 8680inline bool algo::RnullStr151::operator ==(const algo::strptr &rhs) const {
 8681    return algo::RnullStr151_EqStrptr(const_cast<algo::RnullStr151&>(*this),rhs);
 8682}
 8683
 8684inline bool algo::RnullStr151::operator <(const algo::RnullStr151 &rhs) const {
 8685    return algo::RnullStr151_Lt(const_cast<algo::RnullStr151&>(*this),const_cast<algo::RnullStr151&>(rhs));
 8686}
 8687
 8688inline bool algo::RnullStr151::operator >(const algo::RnullStr151 &rhs) const {
 8689    return rhs < *this;
 8690}
 8691
 8692inline bool algo::RnullStr151::operator <=(const algo::RnullStr151 &rhs) const {
 8693    return !(rhs < *this);
 8694}
 8695
 8696inline bool algo::RnullStr151::operator >=(const algo::RnullStr151 &rhs) const {
 8697    return !(*this < rhs);
 8698}
 8699inline algo::RnullStr151::RnullStr151() {
 8700    algo::RnullStr151_Init(*this);
 8701}
 8702
 8703
 8704// --- algo.RnullStr151.ch.Getary
 8705// Access string as array of chars
 8706inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr151& parent) {
 8707    int len = ch_N(parent);
 8708    algo::aryptr<char> ret((char*)parent.ch, len);
 8709    return ret;
 8710}
 8711
 8712// --- algo.RnullStr151.ch.HashStrptr
 8713inline u32 algo::RnullStr151_Hash(u32 prev, const algo::strptr &str) {
 8714    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8715}
 8716
 8717// --- algo.RnullStr151.ch.Init
 8718inline void algo::ch_Init(algo::RnullStr151 &parent) {
 8719    memset(parent.ch, 0, 151);
 8720}
 8721
 8722// --- algo.RnullStr151.ch.Max
 8723// always return constant 151
 8724inline int algo::ch_Max(algo::RnullStr151& parent) {
 8725    (void)parent;
 8726    return 151;
 8727}
 8728
 8729// --- algo.RnullStr151.ch.N
 8730inline int algo::ch_N(const algo::RnullStr151& parent) {
 8731    u64 ret;
 8732    ret = 151;
 8733    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8734        ret--;
 8735    }
 8736    return int(ret);
 8737}
 8738
 8739// --- algo.RnullStr151.ch.AssignStrptr
 8740// Copy from strptr (operator=)
 8741inline void algo::RnullStr151::operator =(const algo::strptr &str) {
 8742    ch_SetStrptr(*this, str);
 8743}
 8744
 8745// --- algo.RnullStr151.ch.Set
 8746// Copy from same type
 8747// Copy value from RHS.
 8748inline void algo::RnullStr151::operator =(const algo::RnullStr151& parent) {
 8749    memcpy(ch, parent.ch, 151);
 8750}
 8751
 8752// --- algo.RnullStr151.ch.Ctor
 8753inline  algo::RnullStr151::RnullStr151(const algo::RnullStr151 &rhs) {
 8754    operator =(rhs);
 8755}
 8756
 8757// --- algo.RnullStr151.ch.CtorStrptr
 8758inline  algo::RnullStr151::RnullStr151(const algo::strptr &rhs) {
 8759    ch_SetStrptr(*this, rhs);
 8760}
 8761
 8762// --- algo.RnullStr151.ch.Cast
 8763inline algo::RnullStr151::operator algo::strptr () const {
 8764    return ch_Getary(*this);
 8765}
 8766
 8767// --- algo.RnullStr151..Lt
 8768inline bool algo::RnullStr151_Lt(algo::RnullStr151& lhs, algo::RnullStr151& rhs) {
 8769    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8770}
 8771
 8772// --- algo.RnullStr151..Cmp
 8773inline i32 algo::RnullStr151_Cmp(algo::RnullStr151& lhs, algo::RnullStr151& rhs) {
 8774    i32 retval = 0;
 8775    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8776    return retval;
 8777}
 8778
 8779// --- algo.RnullStr151..Init
 8780// Set all fields to initial values.
 8781inline void algo::RnullStr151_Init(algo::RnullStr151& parent) {
 8782    memset(parent.ch, 0, 151);
 8783}
 8784
 8785// --- algo.RnullStr151..Eq
 8786inline bool algo::RnullStr151_Eq(algo::RnullStr151& lhs, algo::RnullStr151& rhs) {
 8787    bool retval = true;
 8788    for (int i=0; i<18 && retval; i++) {
 8789        retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
 8790    }
 8791    retval = retval
 8792    &&*(u32*)(lhs.ch+144) == *(u32*)(rhs.ch+144)
 8793    &&*(u16*)(lhs.ch+148) == *(u16*)(rhs.ch+148)
 8794    &&*(u8*)(lhs.ch+150) == *(u8*)(rhs.ch+150);
 8795    return retval;
 8796}
 8797
 8798// --- algo.RnullStr151..Update
 8799// Set value. Return true if new value is different from old value.
 8800inline bool algo::RnullStr151_Update(algo::RnullStr151 &lhs, algo::RnullStr151& rhs) {
 8801    bool ret = !RnullStr151_Eq(lhs, rhs); // compare values
 8802    if (ret) {
 8803        lhs = rhs; // update
 8804    }
 8805    return ret;
 8806}
 8807
 8808// --- algo.RnullStr151..EqStrptr
 8809inline bool algo::RnullStr151_EqStrptr(const algo::RnullStr151& lhs, const algo::strptr& rhs) {
 8810    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8811}
 8812inline algo::RnullStr16::RnullStr16() {
 8813    algo::RnullStr16_Init(*this);
 8814}
 8815
 8816
 8817// --- algo.RnullStr16.ch.Getary
 8818// Access string as array of chars
 8819inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr16& parent) {
 8820    int len = ch_N(parent);
 8821    algo::aryptr<char> ret((char*)parent.ch, len);
 8822    return ret;
 8823}
 8824
 8825// --- algo.RnullStr16.ch.HashStrptr
 8826inline u32 algo::RnullStr16_Hash(u32 prev, const algo::strptr &str) {
 8827    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8828}
 8829
 8830// --- algo.RnullStr16.ch.Init
 8831inline void algo::ch_Init(algo::RnullStr16 &parent) {
 8832    memset(parent.ch, 0, 16);
 8833}
 8834
 8835// --- algo.RnullStr16.ch.Max
 8836// always return constant 16
 8837inline int algo::ch_Max(algo::RnullStr16& parent) {
 8838    (void)parent;
 8839    return 16;
 8840}
 8841
 8842// --- algo.RnullStr16.ch.N
 8843inline int algo::ch_N(const algo::RnullStr16& parent) {
 8844    u64 ret;
 8845    ret = 16;
 8846    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8847        ret--;
 8848    }
 8849    return int(ret);
 8850}
 8851
 8852// --- algo.RnullStr16.ch.AssignStrptr
 8853// Copy from strptr (operator=)
 8854inline void algo::RnullStr16::operator =(const algo::strptr &str) {
 8855    ch_SetStrptr(*this, str);
 8856}
 8857
 8858// --- algo.RnullStr16.ch.Set
 8859// Copy from same type
 8860// Copy value from RHS.
 8861inline void algo::RnullStr16::operator =(const algo::RnullStr16& parent) {
 8862    memcpy(ch, parent.ch, 16);
 8863}
 8864
 8865// --- algo.RnullStr16.ch.Ctor
 8866inline  algo::RnullStr16::RnullStr16(const algo::RnullStr16 &rhs) {
 8867    operator =(rhs);
 8868}
 8869
 8870// --- algo.RnullStr16.ch.CtorStrptr
 8871inline  algo::RnullStr16::RnullStr16(const algo::strptr &rhs) {
 8872    ch_SetStrptr(*this, rhs);
 8873}
 8874
 8875// --- algo.RnullStr16.ch.Cast
 8876inline algo::RnullStr16::operator algo::strptr () const {
 8877    return ch_Getary(*this);
 8878}
 8879
 8880// --- algo.RnullStr16..Lt
 8881inline bool algo::RnullStr16_Lt(algo::RnullStr16 lhs, algo::RnullStr16 rhs) {
 8882    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 8883}
 8884
 8885// --- algo.RnullStr16..Cmp
 8886inline i32 algo::RnullStr16_Cmp(algo::RnullStr16 lhs, algo::RnullStr16 rhs) {
 8887    i32 retval = 0;
 8888    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 8889    return retval;
 8890}
 8891
 8892// --- algo.RnullStr16..Init
 8893// Set all fields to initial values.
 8894inline void algo::RnullStr16_Init(algo::RnullStr16& parent) {
 8895    memset(parent.ch, 0, 16);
 8896}
 8897
 8898// --- algo.RnullStr16..Eq
 8899inline bool algo::RnullStr16_Eq(algo::RnullStr16 lhs, algo::RnullStr16 rhs) {
 8900    bool retval = true;
 8901    retval = retval
 8902    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 8903    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8);
 8904    return retval;
 8905}
 8906
 8907// --- algo.RnullStr16..Update
 8908// Set value. Return true if new value is different from old value.
 8909inline bool algo::RnullStr16_Update(algo::RnullStr16 &lhs, algo::RnullStr16 rhs) {
 8910    bool ret = !RnullStr16_Eq(lhs, rhs); // compare values
 8911    if (ret) {
 8912        lhs = rhs; // update
 8913    }
 8914    return ret;
 8915}
 8916
 8917// --- algo.RnullStr16..EqStrptr
 8918inline bool algo::RnullStr16_EqStrptr(algo::RnullStr16 lhs, const algo::strptr& rhs) {
 8919    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 8920}
 8921
 8922inline bool algo::RnullStr17::operator ==(const algo::RnullStr17 &rhs) const {
 8923    return algo::RnullStr17_Eq(const_cast<algo::RnullStr17&>(*this),const_cast<algo::RnullStr17&>(rhs));
 8924}
 8925
 8926inline bool algo::RnullStr17::operator !=(const algo::RnullStr17 &rhs) const {
 8927    return !algo::RnullStr17_Eq(const_cast<algo::RnullStr17&>(*this),const_cast<algo::RnullStr17&>(rhs));
 8928}
 8929
 8930inline bool algo::RnullStr17::operator ==(const algo::strptr &rhs) const {
 8931    return algo::RnullStr17_EqStrptr(const_cast<algo::RnullStr17&>(*this),rhs);
 8932}
 8933
 8934inline bool algo::RnullStr17::operator <(const algo::RnullStr17 &rhs) const {
 8935    return algo::RnullStr17_Lt(const_cast<algo::RnullStr17&>(*this),const_cast<algo::RnullStr17&>(rhs));
 8936}
 8937
 8938inline bool algo::RnullStr17::operator >(const algo::RnullStr17 &rhs) const {
 8939    return rhs < *this;
 8940}
 8941
 8942inline bool algo::RnullStr17::operator <=(const algo::RnullStr17 &rhs) const {
 8943    return !(rhs < *this);
 8944}
 8945
 8946inline bool algo::RnullStr17::operator >=(const algo::RnullStr17 &rhs) const {
 8947    return !(*this < rhs);
 8948}
 8949inline algo::RnullStr17::RnullStr17() {
 8950    algo::RnullStr17_Init(*this);
 8951}
 8952
 8953
 8954// --- algo.RnullStr17.ch.Getary
 8955// Access string as array of chars
 8956inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr17& parent) {
 8957    int len = ch_N(parent);
 8958    algo::aryptr<char> ret((char*)parent.ch, len);
 8959    return ret;
 8960}
 8961
 8962// --- algo.RnullStr17.ch.HashStrptr
 8963inline u32 algo::RnullStr17_Hash(u32 prev, const algo::strptr &str) {
 8964    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 8965}
 8966
 8967// --- algo.RnullStr17.ch.Init
 8968inline void algo::ch_Init(algo::RnullStr17 &parent) {
 8969    memset(parent.ch, 0, 17);
 8970}
 8971
 8972// --- algo.RnullStr17.ch.Max
 8973// always return constant 17
 8974inline int algo::ch_Max(algo::RnullStr17& parent) {
 8975    (void)parent;
 8976    return 17;
 8977}
 8978
 8979// --- algo.RnullStr17.ch.N
 8980inline int algo::ch_N(const algo::RnullStr17& parent) {
 8981    u64 ret;
 8982    ret = 17;
 8983    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 8984        ret--;
 8985    }
 8986    return int(ret);
 8987}
 8988
 8989// --- algo.RnullStr17.ch.AssignStrptr
 8990// Copy from strptr (operator=)
 8991inline void algo::RnullStr17::operator =(const algo::strptr &str) {
 8992    ch_SetStrptr(*this, str);
 8993}
 8994
 8995// --- algo.RnullStr17.ch.Set
 8996// Copy from same type
 8997// Copy value from RHS.
 8998inline void algo::RnullStr17::operator =(const algo::RnullStr17& parent) {
 8999    memcpy(ch, parent.ch, 17);
 9000}
 9001
 9002// --- algo.RnullStr17.ch.Ctor
 9003inline  algo::RnullStr17::RnullStr17(const algo::RnullStr17 &rhs) {
 9004    operator =(rhs);
 9005}
 9006
 9007// --- algo.RnullStr17.ch.CtorStrptr
 9008inline  algo::RnullStr17::RnullStr17(const algo::strptr &rhs) {
 9009    ch_SetStrptr(*this, rhs);
 9010}
 9011
 9012// --- algo.RnullStr17.ch.Cast
 9013inline algo::RnullStr17::operator algo::strptr () const {
 9014    return ch_Getary(*this);
 9015}
 9016
 9017// --- algo.RnullStr17..Lt
 9018inline bool algo::RnullStr17_Lt(algo::RnullStr17& lhs, algo::RnullStr17& rhs) {
 9019    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9020}
 9021
 9022// --- algo.RnullStr17..Cmp
 9023inline i32 algo::RnullStr17_Cmp(algo::RnullStr17& lhs, algo::RnullStr17& rhs) {
 9024    i32 retval = 0;
 9025    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9026    return retval;
 9027}
 9028
 9029// --- algo.RnullStr17..Init
 9030// Set all fields to initial values.
 9031inline void algo::RnullStr17_Init(algo::RnullStr17& parent) {
 9032    memset(parent.ch, 0, 17);
 9033}
 9034
 9035// --- algo.RnullStr17..Eq
 9036inline bool algo::RnullStr17_Eq(algo::RnullStr17& lhs, algo::RnullStr17& rhs) {
 9037    bool retval = true;
 9038    retval = retval
 9039    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9040    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9041    &&*(u8*)(lhs.ch+16) == *(u8*)(rhs.ch+16);
 9042    return retval;
 9043}
 9044
 9045// --- algo.RnullStr17..Update
 9046// Set value. Return true if new value is different from old value.
 9047inline bool algo::RnullStr17_Update(algo::RnullStr17 &lhs, algo::RnullStr17& rhs) {
 9048    bool ret = !RnullStr17_Eq(lhs, rhs); // compare values
 9049    if (ret) {
 9050        lhs = rhs; // update
 9051    }
 9052    return ret;
 9053}
 9054
 9055// --- algo.RnullStr17..EqStrptr
 9056inline bool algo::RnullStr17_EqStrptr(const algo::RnullStr17& lhs, const algo::strptr& rhs) {
 9057    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9058}
 9059
 9060inline bool algo::RnullStr18::operator ==(const algo::RnullStr18 &rhs) const {
 9061    return algo::RnullStr18_Eq(const_cast<algo::RnullStr18&>(*this),const_cast<algo::RnullStr18&>(rhs));
 9062}
 9063
 9064inline bool algo::RnullStr18::operator !=(const algo::RnullStr18 &rhs) const {
 9065    return !algo::RnullStr18_Eq(const_cast<algo::RnullStr18&>(*this),const_cast<algo::RnullStr18&>(rhs));
 9066}
 9067
 9068inline bool algo::RnullStr18::operator ==(const algo::strptr &rhs) const {
 9069    return algo::RnullStr18_EqStrptr(const_cast<algo::RnullStr18&>(*this),rhs);
 9070}
 9071
 9072inline bool algo::RnullStr18::operator <(const algo::RnullStr18 &rhs) const {
 9073    return algo::RnullStr18_Lt(const_cast<algo::RnullStr18&>(*this),const_cast<algo::RnullStr18&>(rhs));
 9074}
 9075
 9076inline bool algo::RnullStr18::operator >(const algo::RnullStr18 &rhs) const {
 9077    return rhs < *this;
 9078}
 9079
 9080inline bool algo::RnullStr18::operator <=(const algo::RnullStr18 &rhs) const {
 9081    return !(rhs < *this);
 9082}
 9083
 9084inline bool algo::RnullStr18::operator >=(const algo::RnullStr18 &rhs) const {
 9085    return !(*this < rhs);
 9086}
 9087inline algo::RnullStr18::RnullStr18() {
 9088    algo::RnullStr18_Init(*this);
 9089}
 9090
 9091
 9092// --- algo.RnullStr18.ch.Getary
 9093// Access string as array of chars
 9094inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr18& parent) {
 9095    int len = ch_N(parent);
 9096    algo::aryptr<char> ret((char*)parent.ch, len);
 9097    return ret;
 9098}
 9099
 9100// --- algo.RnullStr18.ch.HashStrptr
 9101inline u32 algo::RnullStr18_Hash(u32 prev, const algo::strptr &str) {
 9102    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9103}
 9104
 9105// --- algo.RnullStr18.ch.Init
 9106inline void algo::ch_Init(algo::RnullStr18 &parent) {
 9107    memset(parent.ch, 0, 18);
 9108}
 9109
 9110// --- algo.RnullStr18.ch.Max
 9111// always return constant 18
 9112inline int algo::ch_Max(algo::RnullStr18& parent) {
 9113    (void)parent;
 9114    return 18;
 9115}
 9116
 9117// --- algo.RnullStr18.ch.N
 9118inline int algo::ch_N(const algo::RnullStr18& parent) {
 9119    u64 ret;
 9120    ret = 18;
 9121    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9122        ret--;
 9123    }
 9124    return int(ret);
 9125}
 9126
 9127// --- algo.RnullStr18.ch.AssignStrptr
 9128// Copy from strptr (operator=)
 9129inline void algo::RnullStr18::operator =(const algo::strptr &str) {
 9130    ch_SetStrptr(*this, str);
 9131}
 9132
 9133// --- algo.RnullStr18.ch.Set
 9134// Copy from same type
 9135// Copy value from RHS.
 9136inline void algo::RnullStr18::operator =(const algo::RnullStr18& parent) {
 9137    memcpy(ch, parent.ch, 18);
 9138}
 9139
 9140// --- algo.RnullStr18.ch.Ctor
 9141inline  algo::RnullStr18::RnullStr18(const algo::RnullStr18 &rhs) {
 9142    operator =(rhs);
 9143}
 9144
 9145// --- algo.RnullStr18.ch.CtorStrptr
 9146inline  algo::RnullStr18::RnullStr18(const algo::strptr &rhs) {
 9147    ch_SetStrptr(*this, rhs);
 9148}
 9149
 9150// --- algo.RnullStr18.ch.Cast
 9151inline algo::RnullStr18::operator algo::strptr () const {
 9152    return ch_Getary(*this);
 9153}
 9154
 9155// --- algo.RnullStr18..Lt
 9156inline bool algo::RnullStr18_Lt(algo::RnullStr18 lhs, algo::RnullStr18 rhs) {
 9157    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9158}
 9159
 9160// --- algo.RnullStr18..Cmp
 9161inline i32 algo::RnullStr18_Cmp(algo::RnullStr18 lhs, algo::RnullStr18 rhs) {
 9162    i32 retval = 0;
 9163    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9164    return retval;
 9165}
 9166
 9167// --- algo.RnullStr18..Init
 9168// Set all fields to initial values.
 9169inline void algo::RnullStr18_Init(algo::RnullStr18& parent) {
 9170    memset(parent.ch, 0, 18);
 9171}
 9172
 9173// --- algo.RnullStr18..Eq
 9174inline bool algo::RnullStr18_Eq(algo::RnullStr18 lhs, algo::RnullStr18 rhs) {
 9175    bool retval = true;
 9176    retval = retval
 9177    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9178    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9179    &&*(u16*)(lhs.ch+16) == *(u16*)(rhs.ch+16);
 9180    return retval;
 9181}
 9182
 9183// --- algo.RnullStr18..Update
 9184// Set value. Return true if new value is different from old value.
 9185inline bool algo::RnullStr18_Update(algo::RnullStr18 &lhs, algo::RnullStr18 rhs) {
 9186    bool ret = !RnullStr18_Eq(lhs, rhs); // compare values
 9187    if (ret) {
 9188        lhs = rhs; // update
 9189    }
 9190    return ret;
 9191}
 9192
 9193// --- algo.RnullStr18..EqStrptr
 9194inline bool algo::RnullStr18_EqStrptr(algo::RnullStr18 lhs, const algo::strptr& rhs) {
 9195    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9196}
 9197inline algo::RnullStr19::RnullStr19() {
 9198    algo::RnullStr19_Init(*this);
 9199}
 9200
 9201
 9202// --- algo.RnullStr19.ch.Getary
 9203// Access string as array of chars
 9204inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr19& parent) {
 9205    int len = ch_N(parent);
 9206    algo::aryptr<char> ret((char*)parent.ch, len);
 9207    return ret;
 9208}
 9209
 9210// --- algo.RnullStr19.ch.HashStrptr
 9211inline u32 algo::RnullStr19_Hash(u32 prev, const algo::strptr &str) {
 9212    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9213}
 9214
 9215// --- algo.RnullStr19.ch.Init
 9216inline void algo::ch_Init(algo::RnullStr19 &parent) {
 9217    memset(parent.ch, 0, 19);
 9218}
 9219
 9220// --- algo.RnullStr19.ch.Max
 9221// always return constant 19
 9222inline int algo::ch_Max(algo::RnullStr19& parent) {
 9223    (void)parent;
 9224    return 19;
 9225}
 9226
 9227// --- algo.RnullStr19.ch.N
 9228inline int algo::ch_N(const algo::RnullStr19& parent) {
 9229    u64 ret;
 9230    ret = 19;
 9231    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9232        ret--;
 9233    }
 9234    return int(ret);
 9235}
 9236
 9237// --- algo.RnullStr19.ch.AssignStrptr
 9238// Copy from strptr (operator=)
 9239inline void algo::RnullStr19::operator =(const algo::strptr &str) {
 9240    ch_SetStrptr(*this, str);
 9241}
 9242
 9243// --- algo.RnullStr19.ch.Set
 9244// Copy from same type
 9245// Copy value from RHS.
 9246inline void algo::RnullStr19::operator =(const algo::RnullStr19& parent) {
 9247    memcpy(ch, parent.ch, 19);
 9248}
 9249
 9250// --- algo.RnullStr19.ch.Ctor
 9251inline  algo::RnullStr19::RnullStr19(const algo::RnullStr19 &rhs) {
 9252    operator =(rhs);
 9253}
 9254
 9255// --- algo.RnullStr19.ch.CtorStrptr
 9256inline  algo::RnullStr19::RnullStr19(const algo::strptr &rhs) {
 9257    ch_SetStrptr(*this, rhs);
 9258}
 9259
 9260// --- algo.RnullStr19.ch.Cast
 9261inline algo::RnullStr19::operator algo::strptr () const {
 9262    return ch_Getary(*this);
 9263}
 9264
 9265// --- algo.RnullStr19..Lt
 9266inline bool algo::RnullStr19_Lt(algo::RnullStr19& lhs, algo::RnullStr19& rhs) {
 9267    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9268}
 9269
 9270// --- algo.RnullStr19..Cmp
 9271inline i32 algo::RnullStr19_Cmp(algo::RnullStr19& lhs, algo::RnullStr19& rhs) {
 9272    i32 retval = 0;
 9273    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9274    return retval;
 9275}
 9276
 9277// --- algo.RnullStr19..Init
 9278// Set all fields to initial values.
 9279inline void algo::RnullStr19_Init(algo::RnullStr19& parent) {
 9280    memset(parent.ch, 0, 19);
 9281}
 9282
 9283// --- algo.RnullStr19..Eq
 9284inline bool algo::RnullStr19_Eq(algo::RnullStr19& lhs, algo::RnullStr19& rhs) {
 9285    bool retval = true;
 9286    retval = retval
 9287    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9288    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9289    &&*(u16*)(lhs.ch+16) == *(u16*)(rhs.ch+16)
 9290    &&*(u8*)(lhs.ch+18) == *(u8*)(rhs.ch+18);
 9291    return retval;
 9292}
 9293
 9294// --- algo.RnullStr19..Update
 9295// Set value. Return true if new value is different from old value.
 9296inline bool algo::RnullStr19_Update(algo::RnullStr19 &lhs, algo::RnullStr19& rhs) {
 9297    bool ret = !RnullStr19_Eq(lhs, rhs); // compare values
 9298    if (ret) {
 9299        lhs = rhs; // update
 9300    }
 9301    return ret;
 9302}
 9303
 9304// --- algo.RnullStr19..EqStrptr
 9305inline bool algo::RnullStr19_EqStrptr(const algo::RnullStr19& lhs, const algo::strptr& rhs) {
 9306    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9307}
 9308
 9309inline bool algo::RnullStr2::operator ==(const algo::RnullStr2 &rhs) const {
 9310    return algo::RnullStr2_Eq(const_cast<algo::RnullStr2&>(*this),const_cast<algo::RnullStr2&>(rhs));
 9311}
 9312
 9313inline bool algo::RnullStr2::operator !=(const algo::RnullStr2 &rhs) const {
 9314    return !algo::RnullStr2_Eq(const_cast<algo::RnullStr2&>(*this),const_cast<algo::RnullStr2&>(rhs));
 9315}
 9316
 9317inline bool algo::RnullStr2::operator ==(const algo::strptr &rhs) const {
 9318    return algo::RnullStr2_EqStrptr(const_cast<algo::RnullStr2&>(*this),rhs);
 9319}
 9320
 9321inline bool algo::RnullStr2::operator <(const algo::RnullStr2 &rhs) const {
 9322    return algo::RnullStr2_Lt(const_cast<algo::RnullStr2&>(*this),const_cast<algo::RnullStr2&>(rhs));
 9323}
 9324
 9325inline bool algo::RnullStr2::operator >(const algo::RnullStr2 &rhs) const {
 9326    return rhs < *this;
 9327}
 9328
 9329inline bool algo::RnullStr2::operator <=(const algo::RnullStr2 &rhs) const {
 9330    return !(rhs < *this);
 9331}
 9332
 9333inline bool algo::RnullStr2::operator >=(const algo::RnullStr2 &rhs) const {
 9334    return !(*this < rhs);
 9335}
 9336inline algo::RnullStr2::RnullStr2() {
 9337    algo::RnullStr2_Init(*this);
 9338}
 9339
 9340
 9341// --- algo.RnullStr2.ch.Getary
 9342// Access string as array of chars
 9343inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr2& parent) {
 9344    int len = ch_N(parent);
 9345    algo::aryptr<char> ret((char*)parent.ch, len);
 9346    return ret;
 9347}
 9348
 9349// --- algo.RnullStr2.ch.HashStrptr
 9350inline u32 algo::RnullStr2_Hash(u32 prev, const algo::strptr &str) {
 9351    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9352}
 9353
 9354// --- algo.RnullStr2.ch.Init
 9355inline void algo::ch_Init(algo::RnullStr2 &parent) {
 9356    memset(parent.ch, 0, 2);
 9357}
 9358
 9359// --- algo.RnullStr2.ch.Max
 9360// always return constant 2
 9361inline int algo::ch_Max(algo::RnullStr2& parent) {
 9362    (void)parent;
 9363    return 2;
 9364}
 9365
 9366// --- algo.RnullStr2.ch.N
 9367inline int algo::ch_N(const algo::RnullStr2& parent) {
 9368    u64 ret;
 9369    ret = 2;
 9370    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9371        ret--;
 9372    }
 9373    return int(ret);
 9374}
 9375
 9376// --- algo.RnullStr2.ch.AssignStrptr
 9377// Copy from strptr (operator=)
 9378inline void algo::RnullStr2::operator =(const algo::strptr &str) {
 9379    ch_SetStrptr(*this, str);
 9380}
 9381
 9382// --- algo.RnullStr2.ch.Set
 9383// Copy from same type
 9384// Copy value from RHS.
 9385inline void algo::RnullStr2::operator =(const algo::RnullStr2& parent) {
 9386    memcpy(ch, parent.ch, 2);
 9387}
 9388
 9389// --- algo.RnullStr2.ch.Ctor
 9390inline  algo::RnullStr2::RnullStr2(const algo::RnullStr2 &rhs) {
 9391    operator =(rhs);
 9392}
 9393
 9394// --- algo.RnullStr2.ch.CtorStrptr
 9395inline  algo::RnullStr2::RnullStr2(const algo::strptr &rhs) {
 9396    ch_SetStrptr(*this, rhs);
 9397}
 9398
 9399// --- algo.RnullStr2.ch.Cast
 9400inline algo::RnullStr2::operator algo::strptr () const {
 9401    return ch_Getary(*this);
 9402}
 9403
 9404// --- algo.RnullStr2..Lt
 9405inline bool algo::RnullStr2_Lt(algo::RnullStr2 lhs, algo::RnullStr2 rhs) {
 9406    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9407}
 9408
 9409// --- algo.RnullStr2..Cmp
 9410inline i32 algo::RnullStr2_Cmp(algo::RnullStr2 lhs, algo::RnullStr2 rhs) {
 9411    i32 retval = 0;
 9412    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9413    return retval;
 9414}
 9415
 9416// --- algo.RnullStr2..Init
 9417// Set all fields to initial values.
 9418inline void algo::RnullStr2_Init(algo::RnullStr2& parent) {
 9419    memset(parent.ch, 0, 2);
 9420}
 9421
 9422// --- algo.RnullStr2..Eq
 9423inline bool algo::RnullStr2_Eq(algo::RnullStr2 lhs, algo::RnullStr2 rhs) {
 9424    bool retval = true;
 9425    retval = retval
 9426    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0);
 9427    return retval;
 9428}
 9429
 9430// --- algo.RnullStr2..Update
 9431// Set value. Return true if new value is different from old value.
 9432inline bool algo::RnullStr2_Update(algo::RnullStr2 &lhs, algo::RnullStr2 rhs) {
 9433    bool ret = !RnullStr2_Eq(lhs, rhs); // compare values
 9434    if (ret) {
 9435        lhs = rhs; // update
 9436    }
 9437    return ret;
 9438}
 9439
 9440// --- algo.RnullStr2..EqStrptr
 9441inline bool algo::RnullStr2_EqStrptr(algo::RnullStr2 lhs, const algo::strptr& rhs) {
 9442    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9443}
 9444
 9445inline bool algo::RnullStr20::operator ==(const algo::RnullStr20 &rhs) const {
 9446    return algo::RnullStr20_Eq(const_cast<algo::RnullStr20&>(*this),const_cast<algo::RnullStr20&>(rhs));
 9447}
 9448
 9449inline bool algo::RnullStr20::operator !=(const algo::RnullStr20 &rhs) const {
 9450    return !algo::RnullStr20_Eq(const_cast<algo::RnullStr20&>(*this),const_cast<algo::RnullStr20&>(rhs));
 9451}
 9452
 9453inline bool algo::RnullStr20::operator ==(const algo::strptr &rhs) const {
 9454    return algo::RnullStr20_EqStrptr(const_cast<algo::RnullStr20&>(*this),rhs);
 9455}
 9456
 9457inline bool algo::RnullStr20::operator <(const algo::RnullStr20 &rhs) const {
 9458    return algo::RnullStr20_Lt(const_cast<algo::RnullStr20&>(*this),const_cast<algo::RnullStr20&>(rhs));
 9459}
 9460
 9461inline bool algo::RnullStr20::operator >(const algo::RnullStr20 &rhs) const {
 9462    return rhs < *this;
 9463}
 9464
 9465inline bool algo::RnullStr20::operator <=(const algo::RnullStr20 &rhs) const {
 9466    return !(rhs < *this);
 9467}
 9468
 9469inline bool algo::RnullStr20::operator >=(const algo::RnullStr20 &rhs) const {
 9470    return !(*this < rhs);
 9471}
 9472inline algo::RnullStr20::RnullStr20() {
 9473    algo::RnullStr20_Init(*this);
 9474}
 9475
 9476
 9477// --- algo.RnullStr20.ch.Getary
 9478// Access string as array of chars
 9479inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr20& parent) {
 9480    int len = ch_N(parent);
 9481    algo::aryptr<char> ret((char*)parent.ch, len);
 9482    return ret;
 9483}
 9484
 9485// --- algo.RnullStr20.ch.HashStrptr
 9486inline u32 algo::RnullStr20_Hash(u32 prev, const algo::strptr &str) {
 9487    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9488}
 9489
 9490// --- algo.RnullStr20.ch.Init
 9491inline void algo::ch_Init(algo::RnullStr20 &parent) {
 9492    memset(parent.ch, 0, 20);
 9493}
 9494
 9495// --- algo.RnullStr20.ch.Max
 9496// always return constant 20
 9497inline int algo::ch_Max(algo::RnullStr20& parent) {
 9498    (void)parent;
 9499    return 20;
 9500}
 9501
 9502// --- algo.RnullStr20.ch.N
 9503inline int algo::ch_N(const algo::RnullStr20& parent) {
 9504    u64 ret;
 9505    ret = 20;
 9506    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9507        ret--;
 9508    }
 9509    return int(ret);
 9510}
 9511
 9512// --- algo.RnullStr20.ch.AssignStrptr
 9513// Copy from strptr (operator=)
 9514inline void algo::RnullStr20::operator =(const algo::strptr &str) {
 9515    ch_SetStrptr(*this, str);
 9516}
 9517
 9518// --- algo.RnullStr20.ch.Set
 9519// Copy from same type
 9520// Copy value from RHS.
 9521inline void algo::RnullStr20::operator =(const algo::RnullStr20& parent) {
 9522    memcpy(ch, parent.ch, 20);
 9523}
 9524
 9525// --- algo.RnullStr20.ch.Ctor
 9526inline  algo::RnullStr20::RnullStr20(const algo::RnullStr20 &rhs) {
 9527    operator =(rhs);
 9528}
 9529
 9530// --- algo.RnullStr20.ch.CtorStrptr
 9531inline  algo::RnullStr20::RnullStr20(const algo::strptr &rhs) {
 9532    ch_SetStrptr(*this, rhs);
 9533}
 9534
 9535// --- algo.RnullStr20.ch.Cast
 9536inline algo::RnullStr20::operator algo::strptr () const {
 9537    return ch_Getary(*this);
 9538}
 9539
 9540// --- algo.RnullStr20..Lt
 9541inline bool algo::RnullStr20_Lt(algo::RnullStr20 lhs, algo::RnullStr20 rhs) {
 9542    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9543}
 9544
 9545// --- algo.RnullStr20..Cmp
 9546inline i32 algo::RnullStr20_Cmp(algo::RnullStr20 lhs, algo::RnullStr20 rhs) {
 9547    i32 retval = 0;
 9548    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9549    return retval;
 9550}
 9551
 9552// --- algo.RnullStr20..Init
 9553// Set all fields to initial values.
 9554inline void algo::RnullStr20_Init(algo::RnullStr20& parent) {
 9555    memset(parent.ch, 0, 20);
 9556}
 9557
 9558// --- algo.RnullStr20..Eq
 9559inline bool algo::RnullStr20_Eq(algo::RnullStr20 lhs, algo::RnullStr20 rhs) {
 9560    bool retval = true;
 9561    retval = retval
 9562    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9563    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9564    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
 9565    return retval;
 9566}
 9567
 9568// --- algo.RnullStr20..Update
 9569// Set value. Return true if new value is different from old value.
 9570inline bool algo::RnullStr20_Update(algo::RnullStr20 &lhs, algo::RnullStr20 rhs) {
 9571    bool ret = !RnullStr20_Eq(lhs, rhs); // compare values
 9572    if (ret) {
 9573        lhs = rhs; // update
 9574    }
 9575    return ret;
 9576}
 9577
 9578// --- algo.RnullStr20..EqStrptr
 9579inline bool algo::RnullStr20_EqStrptr(algo::RnullStr20 lhs, const algo::strptr& rhs) {
 9580    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9581}
 9582inline algo::RnullStr21::RnullStr21() {
 9583    algo::RnullStr21_Init(*this);
 9584}
 9585
 9586
 9587// --- algo.RnullStr21.ch.Getary
 9588// Access string as array of chars
 9589inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr21& parent) {
 9590    int len = ch_N(parent);
 9591    algo::aryptr<char> ret((char*)parent.ch, len);
 9592    return ret;
 9593}
 9594
 9595// --- algo.RnullStr21.ch.HashStrptr
 9596inline u32 algo::RnullStr21_Hash(u32 prev, const algo::strptr &str) {
 9597    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9598}
 9599
 9600// --- algo.RnullStr21.ch.Init
 9601inline void algo::ch_Init(algo::RnullStr21 &parent) {
 9602    memset(parent.ch, 0, 21);
 9603}
 9604
 9605// --- algo.RnullStr21.ch.Max
 9606// always return constant 21
 9607inline int algo::ch_Max(algo::RnullStr21& parent) {
 9608    (void)parent;
 9609    return 21;
 9610}
 9611
 9612// --- algo.RnullStr21.ch.N
 9613inline int algo::ch_N(const algo::RnullStr21& parent) {
 9614    u64 ret;
 9615    ret = 21;
 9616    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9617        ret--;
 9618    }
 9619    return int(ret);
 9620}
 9621
 9622// --- algo.RnullStr21.ch.AssignStrptr
 9623// Copy from strptr (operator=)
 9624inline void algo::RnullStr21::operator =(const algo::strptr &str) {
 9625    ch_SetStrptr(*this, str);
 9626}
 9627
 9628// --- algo.RnullStr21.ch.Set
 9629// Copy from same type
 9630// Copy value from RHS.
 9631inline void algo::RnullStr21::operator =(const algo::RnullStr21& parent) {
 9632    memcpy(ch, parent.ch, 21);
 9633}
 9634
 9635// --- algo.RnullStr21.ch.Ctor
 9636inline  algo::RnullStr21::RnullStr21(const algo::RnullStr21 &rhs) {
 9637    operator =(rhs);
 9638}
 9639
 9640// --- algo.RnullStr21.ch.CtorStrptr
 9641inline  algo::RnullStr21::RnullStr21(const algo::strptr &rhs) {
 9642    ch_SetStrptr(*this, rhs);
 9643}
 9644
 9645// --- algo.RnullStr21.ch.Cast
 9646inline algo::RnullStr21::operator algo::strptr () const {
 9647    return ch_Getary(*this);
 9648}
 9649
 9650// --- algo.RnullStr21..Lt
 9651inline bool algo::RnullStr21_Lt(algo::RnullStr21& lhs, algo::RnullStr21& rhs) {
 9652    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9653}
 9654
 9655// --- algo.RnullStr21..Cmp
 9656inline i32 algo::RnullStr21_Cmp(algo::RnullStr21& lhs, algo::RnullStr21& rhs) {
 9657    i32 retval = 0;
 9658    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9659    return retval;
 9660}
 9661
 9662// --- algo.RnullStr21..Init
 9663// Set all fields to initial values.
 9664inline void algo::RnullStr21_Init(algo::RnullStr21& parent) {
 9665    memset(parent.ch, 0, 21);
 9666}
 9667
 9668// --- algo.RnullStr21..Eq
 9669inline bool algo::RnullStr21_Eq(algo::RnullStr21& lhs, algo::RnullStr21& rhs) {
 9670    bool retval = true;
 9671    retval = retval
 9672    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9673    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9674    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16)
 9675    &&*(u8*)(lhs.ch+20) == *(u8*)(rhs.ch+20);
 9676    return retval;
 9677}
 9678
 9679// --- algo.RnullStr21..Update
 9680// Set value. Return true if new value is different from old value.
 9681inline bool algo::RnullStr21_Update(algo::RnullStr21 &lhs, algo::RnullStr21& rhs) {
 9682    bool ret = !RnullStr21_Eq(lhs, rhs); // compare values
 9683    if (ret) {
 9684        lhs = rhs; // update
 9685    }
 9686    return ret;
 9687}
 9688
 9689// --- algo.RnullStr21..EqStrptr
 9690inline bool algo::RnullStr21_EqStrptr(const algo::RnullStr21& lhs, const algo::strptr& rhs) {
 9691    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9692}
 9693
 9694inline bool algo::RnullStr24::operator ==(const algo::RnullStr24 &rhs) const {
 9695    return algo::RnullStr24_Eq(const_cast<algo::RnullStr24&>(*this),const_cast<algo::RnullStr24&>(rhs));
 9696}
 9697
 9698inline bool algo::RnullStr24::operator !=(const algo::RnullStr24 &rhs) const {
 9699    return !algo::RnullStr24_Eq(const_cast<algo::RnullStr24&>(*this),const_cast<algo::RnullStr24&>(rhs));
 9700}
 9701
 9702inline bool algo::RnullStr24::operator ==(const algo::strptr &rhs) const {
 9703    return algo::RnullStr24_EqStrptr(const_cast<algo::RnullStr24&>(*this),rhs);
 9704}
 9705
 9706inline bool algo::RnullStr24::operator <(const algo::RnullStr24 &rhs) const {
 9707    return algo::RnullStr24_Lt(const_cast<algo::RnullStr24&>(*this),const_cast<algo::RnullStr24&>(rhs));
 9708}
 9709
 9710inline bool algo::RnullStr24::operator >(const algo::RnullStr24 &rhs) const {
 9711    return rhs < *this;
 9712}
 9713
 9714inline bool algo::RnullStr24::operator <=(const algo::RnullStr24 &rhs) const {
 9715    return !(rhs < *this);
 9716}
 9717
 9718inline bool algo::RnullStr24::operator >=(const algo::RnullStr24 &rhs) const {
 9719    return !(*this < rhs);
 9720}
 9721inline algo::RnullStr24::RnullStr24() {
 9722    algo::RnullStr24_Init(*this);
 9723}
 9724
 9725
 9726// --- algo.RnullStr24.ch.Getary
 9727// Access string as array of chars
 9728inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr24& parent) {
 9729    int len = ch_N(parent);
 9730    algo::aryptr<char> ret((char*)parent.ch, len);
 9731    return ret;
 9732}
 9733
 9734// --- algo.RnullStr24.ch.HashStrptr
 9735inline u32 algo::RnullStr24_Hash(u32 prev, const algo::strptr &str) {
 9736    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9737}
 9738
 9739// --- algo.RnullStr24.ch.Init
 9740inline void algo::ch_Init(algo::RnullStr24 &parent) {
 9741    memset(parent.ch, 0, 24);
 9742}
 9743
 9744// --- algo.RnullStr24.ch.Max
 9745// always return constant 24
 9746inline int algo::ch_Max(algo::RnullStr24& parent) {
 9747    (void)parent;
 9748    return 24;
 9749}
 9750
 9751// --- algo.RnullStr24.ch.N
 9752inline int algo::ch_N(const algo::RnullStr24& parent) {
 9753    u64 ret;
 9754    ret = 24;
 9755    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9756        ret--;
 9757    }
 9758    return int(ret);
 9759}
 9760
 9761// --- algo.RnullStr24.ch.AssignStrptr
 9762// Copy from strptr (operator=)
 9763inline void algo::RnullStr24::operator =(const algo::strptr &str) {
 9764    ch_SetStrptr(*this, str);
 9765}
 9766
 9767// --- algo.RnullStr24.ch.Set
 9768// Copy from same type
 9769// Copy value from RHS.
 9770inline void algo::RnullStr24::operator =(const algo::RnullStr24& parent) {
 9771    memcpy(ch, parent.ch, 24);
 9772}
 9773
 9774// --- algo.RnullStr24.ch.Ctor
 9775inline  algo::RnullStr24::RnullStr24(const algo::RnullStr24 &rhs) {
 9776    operator =(rhs);
 9777}
 9778
 9779// --- algo.RnullStr24.ch.CtorStrptr
 9780inline  algo::RnullStr24::RnullStr24(const algo::strptr &rhs) {
 9781    ch_SetStrptr(*this, rhs);
 9782}
 9783
 9784// --- algo.RnullStr24.ch.Cast
 9785inline algo::RnullStr24::operator algo::strptr () const {
 9786    return ch_Getary(*this);
 9787}
 9788
 9789// --- algo.RnullStr24..Lt
 9790inline bool algo::RnullStr24_Lt(algo::RnullStr24& lhs, algo::RnullStr24& rhs) {
 9791    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9792}
 9793
 9794// --- algo.RnullStr24..Cmp
 9795inline i32 algo::RnullStr24_Cmp(algo::RnullStr24& lhs, algo::RnullStr24& rhs) {
 9796    i32 retval = 0;
 9797    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9798    return retval;
 9799}
 9800
 9801// --- algo.RnullStr24..Init
 9802// Set all fields to initial values.
 9803inline void algo::RnullStr24_Init(algo::RnullStr24& parent) {
 9804    memset(parent.ch, 0, 24);
 9805}
 9806
 9807// --- algo.RnullStr24..Eq
 9808inline bool algo::RnullStr24_Eq(algo::RnullStr24& lhs, algo::RnullStr24& rhs) {
 9809    bool retval = true;
 9810    retval = retval
 9811    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9812    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9813    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16);
 9814    return retval;
 9815}
 9816
 9817// --- algo.RnullStr24..Update
 9818// Set value. Return true if new value is different from old value.
 9819inline bool algo::RnullStr24_Update(algo::RnullStr24 &lhs, algo::RnullStr24& rhs) {
 9820    bool ret = !RnullStr24_Eq(lhs, rhs); // compare values
 9821    if (ret) {
 9822        lhs = rhs; // update
 9823    }
 9824    return ret;
 9825}
 9826
 9827// --- algo.RnullStr24..EqStrptr
 9828inline bool algo::RnullStr24_EqStrptr(const algo::RnullStr24& lhs, const algo::strptr& rhs) {
 9829    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9830}
 9831
 9832inline bool algo::RnullStr25::operator ==(const algo::RnullStr25 &rhs) const {
 9833    return algo::RnullStr25_Eq(const_cast<algo::RnullStr25&>(*this),const_cast<algo::RnullStr25&>(rhs));
 9834}
 9835
 9836inline bool algo::RnullStr25::operator !=(const algo::RnullStr25 &rhs) const {
 9837    return !algo::RnullStr25_Eq(const_cast<algo::RnullStr25&>(*this),const_cast<algo::RnullStr25&>(rhs));
 9838}
 9839
 9840inline bool algo::RnullStr25::operator ==(const algo::strptr &rhs) const {
 9841    return algo::RnullStr25_EqStrptr(const_cast<algo::RnullStr25&>(*this),rhs);
 9842}
 9843
 9844inline bool algo::RnullStr25::operator <(const algo::RnullStr25 &rhs) const {
 9845    return algo::RnullStr25_Lt(const_cast<algo::RnullStr25&>(*this),const_cast<algo::RnullStr25&>(rhs));
 9846}
 9847
 9848inline bool algo::RnullStr25::operator >(const algo::RnullStr25 &rhs) const {
 9849    return rhs < *this;
 9850}
 9851
 9852inline bool algo::RnullStr25::operator <=(const algo::RnullStr25 &rhs) const {
 9853    return !(rhs < *this);
 9854}
 9855
 9856inline bool algo::RnullStr25::operator >=(const algo::RnullStr25 &rhs) const {
 9857    return !(*this < rhs);
 9858}
 9859inline algo::RnullStr25::RnullStr25() {
 9860    algo::RnullStr25_Init(*this);
 9861}
 9862
 9863
 9864// --- algo.RnullStr25.ch.Getary
 9865// Access string as array of chars
 9866inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr25& parent) {
 9867    int len = ch_N(parent);
 9868    algo::aryptr<char> ret((char*)parent.ch, len);
 9869    return ret;
 9870}
 9871
 9872// --- algo.RnullStr25.ch.HashStrptr
 9873inline u32 algo::RnullStr25_Hash(u32 prev, const algo::strptr &str) {
 9874    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
 9875}
 9876
 9877// --- algo.RnullStr25.ch.Init
 9878inline void algo::ch_Init(algo::RnullStr25 &parent) {
 9879    memset(parent.ch, 0, 25);
 9880}
 9881
 9882// --- algo.RnullStr25.ch.Max
 9883// always return constant 25
 9884inline int algo::ch_Max(algo::RnullStr25& parent) {
 9885    (void)parent;
 9886    return 25;
 9887}
 9888
 9889// --- algo.RnullStr25.ch.N
 9890inline int algo::ch_N(const algo::RnullStr25& parent) {
 9891    u64 ret;
 9892    ret = 25;
 9893    while (ret>0 && parent.ch[ret-1]==u8(0)) {
 9894        ret--;
 9895    }
 9896    return int(ret);
 9897}
 9898
 9899// --- algo.RnullStr25.ch.AssignStrptr
 9900// Copy from strptr (operator=)
 9901inline void algo::RnullStr25::operator =(const algo::strptr &str) {
 9902    ch_SetStrptr(*this, str);
 9903}
 9904
 9905// --- algo.RnullStr25.ch.Set
 9906// Copy from same type
 9907// Copy value from RHS.
 9908inline void algo::RnullStr25::operator =(const algo::RnullStr25& parent) {
 9909    memcpy(ch, parent.ch, 25);
 9910}
 9911
 9912// --- algo.RnullStr25.ch.Ctor
 9913inline  algo::RnullStr25::RnullStr25(const algo::RnullStr25 &rhs) {
 9914    operator =(rhs);
 9915}
 9916
 9917// --- algo.RnullStr25.ch.CtorStrptr
 9918inline  algo::RnullStr25::RnullStr25(const algo::strptr &rhs) {
 9919    ch_SetStrptr(*this, rhs);
 9920}
 9921
 9922// --- algo.RnullStr25.ch.Cast
 9923inline algo::RnullStr25::operator algo::strptr () const {
 9924    return ch_Getary(*this);
 9925}
 9926
 9927// --- algo.RnullStr25..Lt
 9928inline bool algo::RnullStr25_Lt(algo::RnullStr25& lhs, algo::RnullStr25& rhs) {
 9929    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
 9930}
 9931
 9932// --- algo.RnullStr25..Cmp
 9933inline i32 algo::RnullStr25_Cmp(algo::RnullStr25& lhs, algo::RnullStr25& rhs) {
 9934    i32 retval = 0;
 9935    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
 9936    return retval;
 9937}
 9938
 9939// --- algo.RnullStr25..Init
 9940// Set all fields to initial values.
 9941inline void algo::RnullStr25_Init(algo::RnullStr25& parent) {
 9942    memset(parent.ch, 0, 25);
 9943}
 9944
 9945// --- algo.RnullStr25..Eq
 9946inline bool algo::RnullStr25_Eq(algo::RnullStr25& lhs, algo::RnullStr25& rhs) {
 9947    bool retval = true;
 9948    retval = retval
 9949    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
 9950    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
 9951    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
 9952    &&*(u8*)(lhs.ch+24) == *(u8*)(rhs.ch+24);
 9953    return retval;
 9954}
 9955
 9956// --- algo.RnullStr25..Update
 9957// Set value. Return true if new value is different from old value.
 9958inline bool algo::RnullStr25_Update(algo::RnullStr25 &lhs, algo::RnullStr25& rhs) {
 9959    bool ret = !RnullStr25_Eq(lhs, rhs); // compare values
 9960    if (ret) {
 9961        lhs = rhs; // update
 9962    }
 9963    return ret;
 9964}
 9965
 9966// --- algo.RnullStr25..EqStrptr
 9967inline bool algo::RnullStr25_EqStrptr(const algo::RnullStr25& lhs, const algo::strptr& rhs) {
 9968    return algo::strptr_Eq(ch_Getary(lhs), rhs);
 9969}
 9970
 9971inline bool algo::RnullStr28::operator ==(const algo::RnullStr28 &rhs) const {
 9972    return algo::RnullStr28_Eq(const_cast<algo::RnullStr28&>(*this),const_cast<algo::RnullStr28&>(rhs));
 9973}
 9974
 9975inline bool algo::RnullStr28::operator !=(const algo::RnullStr28 &rhs) const {
 9976    return !algo::RnullStr28_Eq(const_cast<algo::RnullStr28&>(*this),const_cast<algo::RnullStr28&>(rhs));
 9977}
 9978
 9979inline bool algo::RnullStr28::operator ==(const algo::strptr &rhs) const {
 9980    return algo::RnullStr28_EqStrptr(const_cast<algo::RnullStr28&>(*this),rhs);
 9981}
 9982
 9983inline bool algo::RnullStr28::operator <(const algo::RnullStr28 &rhs) const {
 9984    return algo::RnullStr28_Lt(const_cast<algo::RnullStr28&>(*this),const_cast<algo::RnullStr28&>(rhs));
 9985}
 9986
 9987inline bool algo::RnullStr28::operator >(const algo::RnullStr28 &rhs) const {
 9988    return rhs < *this;
 9989}
 9990
 9991inline bool algo::RnullStr28::operator <=(const algo::RnullStr28 &rhs) const {
 9992    return !(rhs < *this);
 9993}
 9994
 9995inline bool algo::RnullStr28::operator >=(const algo::RnullStr28 &rhs) const {
 9996    return !(*this < rhs);
 9997}
 9998inline algo::RnullStr28::RnullStr28() {
 9999    algo::RnullStr28_Init(*this);
10000}
10001
10002
10003// --- algo.RnullStr28.ch.Getary
10004// Access string as array of chars
10005inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr28& parent) {
10006    int len = ch_N(parent);
10007    algo::aryptr<char> ret((char*)parent.ch, len);
10008    return ret;
10009}
10010
10011// --- algo.RnullStr28.ch.HashStrptr
10012inline u32 algo::RnullStr28_Hash(u32 prev, const algo::strptr &str) {
10013    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10014}
10015
10016// --- algo.RnullStr28.ch.Init
10017inline void algo::ch_Init(algo::RnullStr28 &parent) {
10018    memset(parent.ch, 0, 28);
10019}
10020
10021// --- algo.RnullStr28.ch.Max
10022// always return constant 28
10023inline int algo::ch_Max(algo::RnullStr28& parent) {
10024    (void)parent;
10025    return 28;
10026}
10027
10028// --- algo.RnullStr28.ch.N
10029inline int algo::ch_N(const algo::RnullStr28& parent) {
10030    u64 ret;
10031    ret = 28;
10032    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10033        ret--;
10034    }
10035    return int(ret);
10036}
10037
10038// --- algo.RnullStr28.ch.AssignStrptr
10039// Copy from strptr (operator=)
10040inline void algo::RnullStr28::operator =(const algo::strptr &str) {
10041    ch_SetStrptr(*this, str);
10042}
10043
10044// --- algo.RnullStr28.ch.Set
10045// Copy from same type
10046// Copy value from RHS.
10047inline void algo::RnullStr28::operator =(const algo::RnullStr28& parent) {
10048    memcpy(ch, parent.ch, 28);
10049}
10050
10051// --- algo.RnullStr28.ch.Ctor
10052inline  algo::RnullStr28::RnullStr28(const algo::RnullStr28 &rhs) {
10053    operator =(rhs);
10054}
10055
10056// --- algo.RnullStr28.ch.CtorStrptr
10057inline  algo::RnullStr28::RnullStr28(const algo::strptr &rhs) {
10058    ch_SetStrptr(*this, rhs);
10059}
10060
10061// --- algo.RnullStr28.ch.Cast
10062inline algo::RnullStr28::operator algo::strptr () const {
10063    return ch_Getary(*this);
10064}
10065
10066// --- algo.RnullStr28..Lt
10067inline bool algo::RnullStr28_Lt(algo::RnullStr28& lhs, algo::RnullStr28& rhs) {
10068    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10069}
10070
10071// --- algo.RnullStr28..Cmp
10072inline i32 algo::RnullStr28_Cmp(algo::RnullStr28& lhs, algo::RnullStr28& rhs) {
10073    i32 retval = 0;
10074    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10075    return retval;
10076}
10077
10078// --- algo.RnullStr28..Init
10079// Set all fields to initial values.
10080inline void algo::RnullStr28_Init(algo::RnullStr28& parent) {
10081    memset(parent.ch, 0, 28);
10082}
10083
10084// --- algo.RnullStr28..Eq
10085inline bool algo::RnullStr28_Eq(algo::RnullStr28& lhs, algo::RnullStr28& rhs) {
10086    bool retval = true;
10087    retval = retval
10088    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10089    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10090    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10091    &&*(u32*)(lhs.ch+24) == *(u32*)(rhs.ch+24);
10092    return retval;
10093}
10094
10095// --- algo.RnullStr28..Update
10096// Set value. Return true if new value is different from old value.
10097inline bool algo::RnullStr28_Update(algo::RnullStr28 &lhs, algo::RnullStr28& rhs) {
10098    bool ret = !RnullStr28_Eq(lhs, rhs); // compare values
10099    if (ret) {
10100        lhs = rhs; // update
10101    }
10102    return ret;
10103}
10104
10105// --- algo.RnullStr28..EqStrptr
10106inline bool algo::RnullStr28_EqStrptr(const algo::RnullStr28& lhs, const algo::strptr& rhs) {
10107    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10108}
10109
10110inline bool algo::RnullStr3::operator ==(const algo::RnullStr3 &rhs) const {
10111    return algo::RnullStr3_Eq(const_cast<algo::RnullStr3&>(*this),const_cast<algo::RnullStr3&>(rhs));
10112}
10113
10114inline bool algo::RnullStr3::operator !=(const algo::RnullStr3 &rhs) const {
10115    return !algo::RnullStr3_Eq(const_cast<algo::RnullStr3&>(*this),const_cast<algo::RnullStr3&>(rhs));
10116}
10117
10118inline bool algo::RnullStr3::operator ==(const algo::strptr &rhs) const {
10119    return algo::RnullStr3_EqStrptr(const_cast<algo::RnullStr3&>(*this),rhs);
10120}
10121
10122inline bool algo::RnullStr3::operator <(const algo::RnullStr3 &rhs) const {
10123    return algo::RnullStr3_Lt(const_cast<algo::RnullStr3&>(*this),const_cast<algo::RnullStr3&>(rhs));
10124}
10125
10126inline bool algo::RnullStr3::operator >(const algo::RnullStr3 &rhs) const {
10127    return rhs < *this;
10128}
10129
10130inline bool algo::RnullStr3::operator <=(const algo::RnullStr3 &rhs) const {
10131    return !(rhs < *this);
10132}
10133
10134inline bool algo::RnullStr3::operator >=(const algo::RnullStr3 &rhs) const {
10135    return !(*this < rhs);
10136}
10137inline algo::RnullStr3::RnullStr3() {
10138    algo::RnullStr3_Init(*this);
10139}
10140
10141
10142// --- algo.RnullStr3.ch.Getary
10143// Access string as array of chars
10144inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr3& parent) {
10145    int len = ch_N(parent);
10146    algo::aryptr<char> ret((char*)parent.ch, len);
10147    return ret;
10148}
10149
10150// --- algo.RnullStr3.ch.HashStrptr
10151inline u32 algo::RnullStr3_Hash(u32 prev, const algo::strptr &str) {
10152    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10153}
10154
10155// --- algo.RnullStr3.ch.Init
10156inline void algo::ch_Init(algo::RnullStr3 &parent) {
10157    memset(parent.ch, 0, 3);
10158}
10159
10160// --- algo.RnullStr3.ch.Max
10161// always return constant 3
10162inline int algo::ch_Max(algo::RnullStr3& parent) {
10163    (void)parent;
10164    return 3;
10165}
10166
10167// --- algo.RnullStr3.ch.N
10168inline int algo::ch_N(const algo::RnullStr3& parent) {
10169    u64 ret;
10170    ret = 3;
10171    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10172        ret--;
10173    }
10174    return int(ret);
10175}
10176
10177// --- algo.RnullStr3.ch.AssignStrptr
10178// Copy from strptr (operator=)
10179inline void algo::RnullStr3::operator =(const algo::strptr &str) {
10180    ch_SetStrptr(*this, str);
10181}
10182
10183// --- algo.RnullStr3.ch.Set
10184// Copy from same type
10185// Copy value from RHS.
10186inline void algo::RnullStr3::operator =(const algo::RnullStr3& parent) {
10187    memcpy(ch, parent.ch, 3);
10188}
10189
10190// --- algo.RnullStr3.ch.Ctor
10191inline  algo::RnullStr3::RnullStr3(const algo::RnullStr3 &rhs) {
10192    operator =(rhs);
10193}
10194
10195// --- algo.RnullStr3.ch.CtorStrptr
10196inline  algo::RnullStr3::RnullStr3(const algo::strptr &rhs) {
10197    ch_SetStrptr(*this, rhs);
10198}
10199
10200// --- algo.RnullStr3.ch.Cast
10201inline algo::RnullStr3::operator algo::strptr () const {
10202    return ch_Getary(*this);
10203}
10204
10205// --- algo.RnullStr3..Lt
10206inline bool algo::RnullStr3_Lt(algo::RnullStr3 lhs, algo::RnullStr3 rhs) {
10207    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10208}
10209
10210// --- algo.RnullStr3..Cmp
10211inline i32 algo::RnullStr3_Cmp(algo::RnullStr3 lhs, algo::RnullStr3 rhs) {
10212    i32 retval = 0;
10213    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10214    return retval;
10215}
10216
10217// --- algo.RnullStr3..Init
10218// Set all fields to initial values.
10219inline void algo::RnullStr3_Init(algo::RnullStr3& parent) {
10220    memset(parent.ch, 0, 3);
10221}
10222
10223// --- algo.RnullStr3..Eq
10224inline bool algo::RnullStr3_Eq(algo::RnullStr3 lhs, algo::RnullStr3 rhs) {
10225    bool retval = true;
10226    retval = retval
10227    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
10228    &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
10229    return retval;
10230}
10231
10232// --- algo.RnullStr3..Update
10233// Set value. Return true if new value is different from old value.
10234inline bool algo::RnullStr3_Update(algo::RnullStr3 &lhs, algo::RnullStr3 rhs) {
10235    bool ret = !RnullStr3_Eq(lhs, rhs); // compare values
10236    if (ret) {
10237        lhs = rhs; // update
10238    }
10239    return ret;
10240}
10241
10242// --- algo.RnullStr3..EqStrptr
10243inline bool algo::RnullStr3_EqStrptr(algo::RnullStr3 lhs, const algo::strptr& rhs) {
10244    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10245}
10246inline algo::RnullStr30::RnullStr30() {
10247    algo::RnullStr30_Init(*this);
10248}
10249
10250
10251// --- algo.RnullStr30.ch.Getary
10252// Access string as array of chars
10253inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr30& parent) {
10254    int len = ch_N(parent);
10255    algo::aryptr<char> ret((char*)parent.ch, len);
10256    return ret;
10257}
10258
10259// --- algo.RnullStr30.ch.HashStrptr
10260inline u32 algo::RnullStr30_Hash(u32 prev, const algo::strptr &str) {
10261    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10262}
10263
10264// --- algo.RnullStr30.ch.Init
10265inline void algo::ch_Init(algo::RnullStr30 &parent) {
10266    memset(parent.ch, 0, 30);
10267}
10268
10269// --- algo.RnullStr30.ch.Max
10270// always return constant 30
10271inline int algo::ch_Max(algo::RnullStr30& parent) {
10272    (void)parent;
10273    return 30;
10274}
10275
10276// --- algo.RnullStr30.ch.N
10277inline int algo::ch_N(const algo::RnullStr30& parent) {
10278    u64 ret;
10279    ret = 30;
10280    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10281        ret--;
10282    }
10283    return int(ret);
10284}
10285
10286// --- algo.RnullStr30.ch.AssignStrptr
10287// Copy from strptr (operator=)
10288inline void algo::RnullStr30::operator =(const algo::strptr &str) {
10289    ch_SetStrptr(*this, str);
10290}
10291
10292// --- algo.RnullStr30.ch.Set
10293// Copy from same type
10294// Copy value from RHS.
10295inline void algo::RnullStr30::operator =(const algo::RnullStr30& parent) {
10296    memcpy(ch, parent.ch, 30);
10297}
10298
10299// --- algo.RnullStr30.ch.Ctor
10300inline  algo::RnullStr30::RnullStr30(const algo::RnullStr30 &rhs) {
10301    operator =(rhs);
10302}
10303
10304// --- algo.RnullStr30.ch.CtorStrptr
10305inline  algo::RnullStr30::RnullStr30(const algo::strptr &rhs) {
10306    ch_SetStrptr(*this, rhs);
10307}
10308
10309// --- algo.RnullStr30.ch.Cast
10310inline algo::RnullStr30::operator algo::strptr () const {
10311    return ch_Getary(*this);
10312}
10313
10314// --- algo.RnullStr30..Lt
10315inline bool algo::RnullStr30_Lt(algo::RnullStr30 lhs, algo::RnullStr30 rhs) {
10316    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10317}
10318
10319// --- algo.RnullStr30..Cmp
10320inline i32 algo::RnullStr30_Cmp(algo::RnullStr30 lhs, algo::RnullStr30 rhs) {
10321    i32 retval = 0;
10322    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10323    return retval;
10324}
10325
10326// --- algo.RnullStr30..Init
10327// Set all fields to initial values.
10328inline void algo::RnullStr30_Init(algo::RnullStr30& parent) {
10329    memset(parent.ch, 0, 30);
10330}
10331
10332// --- algo.RnullStr30..Eq
10333inline bool algo::RnullStr30_Eq(algo::RnullStr30 lhs, algo::RnullStr30 rhs) {
10334    bool retval = true;
10335    retval = retval
10336    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10337    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10338    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10339    &&*(u32*)(lhs.ch+24) == *(u32*)(rhs.ch+24)
10340    &&*(u16*)(lhs.ch+28) == *(u16*)(rhs.ch+28);
10341    return retval;
10342}
10343
10344// --- algo.RnullStr30..Update
10345// Set value. Return true if new value is different from old value.
10346inline bool algo::RnullStr30_Update(algo::RnullStr30 &lhs, algo::RnullStr30 rhs) {
10347    bool ret = !RnullStr30_Eq(lhs, rhs); // compare values
10348    if (ret) {
10349        lhs = rhs; // update
10350    }
10351    return ret;
10352}
10353
10354// --- algo.RnullStr30..EqStrptr
10355inline bool algo::RnullStr30_EqStrptr(algo::RnullStr30 lhs, const algo::strptr& rhs) {
10356    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10357}
10358
10359inline bool algo::RnullStr32::operator ==(const algo::RnullStr32 &rhs) const {
10360    return algo::RnullStr32_Eq(const_cast<algo::RnullStr32&>(*this),const_cast<algo::RnullStr32&>(rhs));
10361}
10362
10363inline bool algo::RnullStr32::operator !=(const algo::RnullStr32 &rhs) const {
10364    return !algo::RnullStr32_Eq(const_cast<algo::RnullStr32&>(*this),const_cast<algo::RnullStr32&>(rhs));
10365}
10366
10367inline bool algo::RnullStr32::operator ==(const algo::strptr &rhs) const {
10368    return algo::RnullStr32_EqStrptr(const_cast<algo::RnullStr32&>(*this),rhs);
10369}
10370
10371inline bool algo::RnullStr32::operator <(const algo::RnullStr32 &rhs) const {
10372    return algo::RnullStr32_Lt(const_cast<algo::RnullStr32&>(*this),const_cast<algo::RnullStr32&>(rhs));
10373}
10374
10375inline bool algo::RnullStr32::operator >(const algo::RnullStr32 &rhs) const {
10376    return rhs < *this;
10377}
10378
10379inline bool algo::RnullStr32::operator <=(const algo::RnullStr32 &rhs) const {
10380    return !(rhs < *this);
10381}
10382
10383inline bool algo::RnullStr32::operator >=(const algo::RnullStr32 &rhs) const {
10384    return !(*this < rhs);
10385}
10386inline algo::RnullStr32::RnullStr32() {
10387    algo::RnullStr32_Init(*this);
10388}
10389
10390
10391// --- algo.RnullStr32.ch.Getary
10392// Access string as array of chars
10393inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr32& parent) {
10394    int len = ch_N(parent);
10395    algo::aryptr<char> ret((char*)parent.ch, len);
10396    return ret;
10397}
10398
10399// --- algo.RnullStr32.ch.HashStrptr
10400inline u32 algo::RnullStr32_Hash(u32 prev, const algo::strptr &str) {
10401    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10402}
10403
10404// --- algo.RnullStr32.ch.Init
10405inline void algo::ch_Init(algo::RnullStr32 &parent) {
10406    memset(parent.ch, 0, 32);
10407}
10408
10409// --- algo.RnullStr32.ch.Max
10410// always return constant 32
10411inline int algo::ch_Max(algo::RnullStr32& parent) {
10412    (void)parent;
10413    return 32;
10414}
10415
10416// --- algo.RnullStr32.ch.N
10417inline int algo::ch_N(const algo::RnullStr32& parent) {
10418    u64 ret;
10419    ret = 32;
10420    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10421        ret--;
10422    }
10423    return int(ret);
10424}
10425
10426// --- algo.RnullStr32.ch.AssignStrptr
10427// Copy from strptr (operator=)
10428inline void algo::RnullStr32::operator =(const algo::strptr &str) {
10429    ch_SetStrptr(*this, str);
10430}
10431
10432// --- algo.RnullStr32.ch.Set
10433// Copy from same type
10434// Copy value from RHS.
10435inline void algo::RnullStr32::operator =(const algo::RnullStr32& parent) {
10436    memcpy(ch, parent.ch, 32);
10437}
10438
10439// --- algo.RnullStr32.ch.Ctor
10440inline  algo::RnullStr32::RnullStr32(const algo::RnullStr32 &rhs) {
10441    operator =(rhs);
10442}
10443
10444// --- algo.RnullStr32.ch.CtorStrptr
10445inline  algo::RnullStr32::RnullStr32(const algo::strptr &rhs) {
10446    ch_SetStrptr(*this, rhs);
10447}
10448
10449// --- algo.RnullStr32.ch.Cast
10450inline algo::RnullStr32::operator algo::strptr () const {
10451    return ch_Getary(*this);
10452}
10453
10454// --- algo.RnullStr32..Lt
10455inline bool algo::RnullStr32_Lt(algo::RnullStr32 lhs, algo::RnullStr32 rhs) {
10456    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10457}
10458
10459// --- algo.RnullStr32..Cmp
10460inline i32 algo::RnullStr32_Cmp(algo::RnullStr32 lhs, algo::RnullStr32 rhs) {
10461    i32 retval = 0;
10462    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10463    return retval;
10464}
10465
10466// --- algo.RnullStr32..Init
10467// Set all fields to initial values.
10468inline void algo::RnullStr32_Init(algo::RnullStr32& parent) {
10469    memset(parent.ch, 0, 32);
10470}
10471
10472// --- algo.RnullStr32..Eq
10473inline bool algo::RnullStr32_Eq(algo::RnullStr32 lhs, algo::RnullStr32 rhs) {
10474    bool retval = true;
10475    retval = retval
10476    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10477    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10478    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10479    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24);
10480    return retval;
10481}
10482
10483// --- algo.RnullStr32..Update
10484// Set value. Return true if new value is different from old value.
10485inline bool algo::RnullStr32_Update(algo::RnullStr32 &lhs, algo::RnullStr32 rhs) {
10486    bool ret = !RnullStr32_Eq(lhs, rhs); // compare values
10487    if (ret) {
10488        lhs = rhs; // update
10489    }
10490    return ret;
10491}
10492
10493// --- algo.RnullStr32..EqStrptr
10494inline bool algo::RnullStr32_EqStrptr(algo::RnullStr32 lhs, const algo::strptr& rhs) {
10495    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10496}
10497
10498inline bool algo::RnullStr33::operator ==(const algo::RnullStr33 &rhs) const {
10499    return algo::RnullStr33_Eq(const_cast<algo::RnullStr33&>(*this),const_cast<algo::RnullStr33&>(rhs));
10500}
10501
10502inline bool algo::RnullStr33::operator !=(const algo::RnullStr33 &rhs) const {
10503    return !algo::RnullStr33_Eq(const_cast<algo::RnullStr33&>(*this),const_cast<algo::RnullStr33&>(rhs));
10504}
10505
10506inline bool algo::RnullStr33::operator ==(const algo::strptr &rhs) const {
10507    return algo::RnullStr33_EqStrptr(const_cast<algo::RnullStr33&>(*this),rhs);
10508}
10509
10510inline bool algo::RnullStr33::operator <(const algo::RnullStr33 &rhs) const {
10511    return algo::RnullStr33_Lt(const_cast<algo::RnullStr33&>(*this),const_cast<algo::RnullStr33&>(rhs));
10512}
10513
10514inline bool algo::RnullStr33::operator >(const algo::RnullStr33 &rhs) const {
10515    return rhs < *this;
10516}
10517
10518inline bool algo::RnullStr33::operator <=(const algo::RnullStr33 &rhs) const {
10519    return !(rhs < *this);
10520}
10521
10522inline bool algo::RnullStr33::operator >=(const algo::RnullStr33 &rhs) const {
10523    return !(*this < rhs);
10524}
10525inline algo::RnullStr33::RnullStr33() {
10526    algo::RnullStr33_Init(*this);
10527}
10528
10529
10530// --- algo.RnullStr33.ch.Getary
10531// Access string as array of chars
10532inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr33& parent) {
10533    int len = ch_N(parent);
10534    algo::aryptr<char> ret((char*)parent.ch, len);
10535    return ret;
10536}
10537
10538// --- algo.RnullStr33.ch.HashStrptr
10539inline u32 algo::RnullStr33_Hash(u32 prev, const algo::strptr &str) {
10540    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10541}
10542
10543// --- algo.RnullStr33.ch.Init
10544inline void algo::ch_Init(algo::RnullStr33 &parent) {
10545    memset(parent.ch, 0, 33);
10546}
10547
10548// --- algo.RnullStr33.ch.Max
10549// always return constant 33
10550inline int algo::ch_Max(algo::RnullStr33& parent) {
10551    (void)parent;
10552    return 33;
10553}
10554
10555// --- algo.RnullStr33.ch.N
10556inline int algo::ch_N(const algo::RnullStr33& parent) {
10557    u64 ret;
10558    ret = 33;
10559    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10560        ret--;
10561    }
10562    return int(ret);
10563}
10564
10565// --- algo.RnullStr33.ch.AssignStrptr
10566// Copy from strptr (operator=)
10567inline void algo::RnullStr33::operator =(const algo::strptr &str) {
10568    ch_SetStrptr(*this, str);
10569}
10570
10571// --- algo.RnullStr33.ch.Set
10572// Copy from same type
10573// Copy value from RHS.
10574inline void algo::RnullStr33::operator =(const algo::RnullStr33& parent) {
10575    memcpy(ch, parent.ch, 33);
10576}
10577
10578// --- algo.RnullStr33.ch.Ctor
10579inline  algo::RnullStr33::RnullStr33(const algo::RnullStr33 &rhs) {
10580    operator =(rhs);
10581}
10582
10583// --- algo.RnullStr33.ch.CtorStrptr
10584inline  algo::RnullStr33::RnullStr33(const algo::strptr &rhs) {
10585    ch_SetStrptr(*this, rhs);
10586}
10587
10588// --- algo.RnullStr33.ch.Cast
10589inline algo::RnullStr33::operator algo::strptr () const {
10590    return ch_Getary(*this);
10591}
10592
10593// --- algo.RnullStr33..Lt
10594inline bool algo::RnullStr33_Lt(algo::RnullStr33& lhs, algo::RnullStr33& rhs) {
10595    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10596}
10597
10598// --- algo.RnullStr33..Cmp
10599inline i32 algo::RnullStr33_Cmp(algo::RnullStr33& lhs, algo::RnullStr33& rhs) {
10600    i32 retval = 0;
10601    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10602    return retval;
10603}
10604
10605// --- algo.RnullStr33..Init
10606// Set all fields to initial values.
10607inline void algo::RnullStr33_Init(algo::RnullStr33& parent) {
10608    memset(parent.ch, 0, 33);
10609}
10610
10611// --- algo.RnullStr33..Eq
10612inline bool algo::RnullStr33_Eq(algo::RnullStr33& lhs, algo::RnullStr33& rhs) {
10613    bool retval = true;
10614    retval = retval
10615    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10616    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10617    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10618    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
10619    &&*(u8*)(lhs.ch+32) == *(u8*)(rhs.ch+32);
10620    return retval;
10621}
10622
10623// --- algo.RnullStr33..Update
10624// Set value. Return true if new value is different from old value.
10625inline bool algo::RnullStr33_Update(algo::RnullStr33 &lhs, algo::RnullStr33& rhs) {
10626    bool ret = !RnullStr33_Eq(lhs, rhs); // compare values
10627    if (ret) {
10628        lhs = rhs; // update
10629    }
10630    return ret;
10631}
10632
10633// --- algo.RnullStr33..EqStrptr
10634inline bool algo::RnullStr33_EqStrptr(const algo::RnullStr33& lhs, const algo::strptr& rhs) {
10635    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10636}
10637
10638inline bool algo::RnullStr35::operator ==(const algo::RnullStr35 &rhs) const {
10639    return algo::RnullStr35_Eq(const_cast<algo::RnullStr35&>(*this),const_cast<algo::RnullStr35&>(rhs));
10640}
10641
10642inline bool algo::RnullStr35::operator !=(const algo::RnullStr35 &rhs) const {
10643    return !algo::RnullStr35_Eq(const_cast<algo::RnullStr35&>(*this),const_cast<algo::RnullStr35&>(rhs));
10644}
10645
10646inline bool algo::RnullStr35::operator ==(const algo::strptr &rhs) const {
10647    return algo::RnullStr35_EqStrptr(const_cast<algo::RnullStr35&>(*this),rhs);
10648}
10649
10650inline bool algo::RnullStr35::operator <(const algo::RnullStr35 &rhs) const {
10651    return algo::RnullStr35_Lt(const_cast<algo::RnullStr35&>(*this),const_cast<algo::RnullStr35&>(rhs));
10652}
10653
10654inline bool algo::RnullStr35::operator >(const algo::RnullStr35 &rhs) const {
10655    return rhs < *this;
10656}
10657
10658inline bool algo::RnullStr35::operator <=(const algo::RnullStr35 &rhs) const {
10659    return !(rhs < *this);
10660}
10661
10662inline bool algo::RnullStr35::operator >=(const algo::RnullStr35 &rhs) const {
10663    return !(*this < rhs);
10664}
10665inline algo::RnullStr35::RnullStr35() {
10666    algo::RnullStr35_Init(*this);
10667}
10668
10669
10670// --- algo.RnullStr35.ch.Getary
10671// Access string as array of chars
10672inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr35& parent) {
10673    int len = ch_N(parent);
10674    algo::aryptr<char> ret((char*)parent.ch, len);
10675    return ret;
10676}
10677
10678// --- algo.RnullStr35.ch.HashStrptr
10679inline u32 algo::RnullStr35_Hash(u32 prev, const algo::strptr &str) {
10680    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10681}
10682
10683// --- algo.RnullStr35.ch.Init
10684inline void algo::ch_Init(algo::RnullStr35 &parent) {
10685    memset(parent.ch, 0, 35);
10686}
10687
10688// --- algo.RnullStr35.ch.Max
10689// always return constant 35
10690inline int algo::ch_Max(algo::RnullStr35& parent) {
10691    (void)parent;
10692    return 35;
10693}
10694
10695// --- algo.RnullStr35.ch.N
10696inline int algo::ch_N(const algo::RnullStr35& parent) {
10697    u64 ret;
10698    ret = 35;
10699    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10700        ret--;
10701    }
10702    return int(ret);
10703}
10704
10705// --- algo.RnullStr35.ch.AssignStrptr
10706// Copy from strptr (operator=)
10707inline void algo::RnullStr35::operator =(const algo::strptr &str) {
10708    ch_SetStrptr(*this, str);
10709}
10710
10711// --- algo.RnullStr35.ch.Set
10712// Copy from same type
10713// Copy value from RHS.
10714inline void algo::RnullStr35::operator =(const algo::RnullStr35& parent) {
10715    memcpy(ch, parent.ch, 35);
10716}
10717
10718// --- algo.RnullStr35.ch.Ctor
10719inline  algo::RnullStr35::RnullStr35(const algo::RnullStr35 &rhs) {
10720    operator =(rhs);
10721}
10722
10723// --- algo.RnullStr35.ch.CtorStrptr
10724inline  algo::RnullStr35::RnullStr35(const algo::strptr &rhs) {
10725    ch_SetStrptr(*this, rhs);
10726}
10727
10728// --- algo.RnullStr35.ch.Cast
10729inline algo::RnullStr35::operator algo::strptr () const {
10730    return ch_Getary(*this);
10731}
10732
10733// --- algo.RnullStr35..Lt
10734inline bool algo::RnullStr35_Lt(algo::RnullStr35& lhs, algo::RnullStr35& rhs) {
10735    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10736}
10737
10738// --- algo.RnullStr35..Cmp
10739inline i32 algo::RnullStr35_Cmp(algo::RnullStr35& lhs, algo::RnullStr35& rhs) {
10740    i32 retval = 0;
10741    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10742    return retval;
10743}
10744
10745// --- algo.RnullStr35..Init
10746// Set all fields to initial values.
10747inline void algo::RnullStr35_Init(algo::RnullStr35& parent) {
10748    memset(parent.ch, 0, 35);
10749}
10750
10751// --- algo.RnullStr35..Eq
10752inline bool algo::RnullStr35_Eq(algo::RnullStr35& lhs, algo::RnullStr35& rhs) {
10753    bool retval = true;
10754    retval = retval
10755    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10756    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10757    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10758    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
10759    &&*(u16*)(lhs.ch+32) == *(u16*)(rhs.ch+32)
10760    &&*(u8*)(lhs.ch+34) == *(u8*)(rhs.ch+34);
10761    return retval;
10762}
10763
10764// --- algo.RnullStr35..Update
10765// Set value. Return true if new value is different from old value.
10766inline bool algo::RnullStr35_Update(algo::RnullStr35 &lhs, algo::RnullStr35& rhs) {
10767    bool ret = !RnullStr35_Eq(lhs, rhs); // compare values
10768    if (ret) {
10769        lhs = rhs; // update
10770    }
10771    return ret;
10772}
10773
10774// --- algo.RnullStr35..EqStrptr
10775inline bool algo::RnullStr35_EqStrptr(const algo::RnullStr35& lhs, const algo::strptr& rhs) {
10776    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10777}
10778
10779inline bool algo::RnullStr36::operator ==(const algo::RnullStr36 &rhs) const {
10780    return algo::RnullStr36_Eq(const_cast<algo::RnullStr36&>(*this),const_cast<algo::RnullStr36&>(rhs));
10781}
10782
10783inline bool algo::RnullStr36::operator !=(const algo::RnullStr36 &rhs) const {
10784    return !algo::RnullStr36_Eq(const_cast<algo::RnullStr36&>(*this),const_cast<algo::RnullStr36&>(rhs));
10785}
10786
10787inline bool algo::RnullStr36::operator ==(const algo::strptr &rhs) const {
10788    return algo::RnullStr36_EqStrptr(const_cast<algo::RnullStr36&>(*this),rhs);
10789}
10790
10791inline bool algo::RnullStr36::operator <(const algo::RnullStr36 &rhs) const {
10792    return algo::RnullStr36_Lt(const_cast<algo::RnullStr36&>(*this),const_cast<algo::RnullStr36&>(rhs));
10793}
10794
10795inline bool algo::RnullStr36::operator >(const algo::RnullStr36 &rhs) const {
10796    return rhs < *this;
10797}
10798
10799inline bool algo::RnullStr36::operator <=(const algo::RnullStr36 &rhs) const {
10800    return !(rhs < *this);
10801}
10802
10803inline bool algo::RnullStr36::operator >=(const algo::RnullStr36 &rhs) const {
10804    return !(*this < rhs);
10805}
10806inline algo::RnullStr36::RnullStr36() {
10807    algo::RnullStr36_Init(*this);
10808}
10809
10810
10811// --- algo.RnullStr36.ch.Getary
10812// Access string as array of chars
10813inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr36& parent) {
10814    int len = ch_N(parent);
10815    algo::aryptr<char> ret((char*)parent.ch, len);
10816    return ret;
10817}
10818
10819// --- algo.RnullStr36.ch.HashStrptr
10820inline u32 algo::RnullStr36_Hash(u32 prev, const algo::strptr &str) {
10821    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10822}
10823
10824// --- algo.RnullStr36.ch.Init
10825inline void algo::ch_Init(algo::RnullStr36 &parent) {
10826    memset(parent.ch, 0, 36);
10827}
10828
10829// --- algo.RnullStr36.ch.Max
10830// always return constant 36
10831inline int algo::ch_Max(algo::RnullStr36& parent) {
10832    (void)parent;
10833    return 36;
10834}
10835
10836// --- algo.RnullStr36.ch.N
10837inline int algo::ch_N(const algo::RnullStr36& parent) {
10838    u64 ret;
10839    ret = 36;
10840    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10841        ret--;
10842    }
10843    return int(ret);
10844}
10845
10846// --- algo.RnullStr36.ch.AssignStrptr
10847// Copy from strptr (operator=)
10848inline void algo::RnullStr36::operator =(const algo::strptr &str) {
10849    ch_SetStrptr(*this, str);
10850}
10851
10852// --- algo.RnullStr36.ch.Set
10853// Copy from same type
10854// Copy value from RHS.
10855inline void algo::RnullStr36::operator =(const algo::RnullStr36& parent) {
10856    memcpy(ch, parent.ch, 36);
10857}
10858
10859// --- algo.RnullStr36.ch.Ctor
10860inline  algo::RnullStr36::RnullStr36(const algo::RnullStr36 &rhs) {
10861    operator =(rhs);
10862}
10863
10864// --- algo.RnullStr36.ch.CtorStrptr
10865inline  algo::RnullStr36::RnullStr36(const algo::strptr &rhs) {
10866    ch_SetStrptr(*this, rhs);
10867}
10868
10869// --- algo.RnullStr36.ch.Cast
10870inline algo::RnullStr36::operator algo::strptr () const {
10871    return ch_Getary(*this);
10872}
10873
10874// --- algo.RnullStr36..Lt
10875inline bool algo::RnullStr36_Lt(algo::RnullStr36& lhs, algo::RnullStr36& rhs) {
10876    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10877}
10878
10879// --- algo.RnullStr36..Cmp
10880inline i32 algo::RnullStr36_Cmp(algo::RnullStr36& lhs, algo::RnullStr36& rhs) {
10881    i32 retval = 0;
10882    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10883    return retval;
10884}
10885
10886// --- algo.RnullStr36..Init
10887// Set all fields to initial values.
10888inline void algo::RnullStr36_Init(algo::RnullStr36& parent) {
10889    memset(parent.ch, 0, 36);
10890}
10891
10892// --- algo.RnullStr36..Eq
10893inline bool algo::RnullStr36_Eq(algo::RnullStr36& lhs, algo::RnullStr36& rhs) {
10894    bool retval = true;
10895    retval = retval
10896    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10897    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10898    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10899    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
10900    &&*(u32*)(lhs.ch+32) == *(u32*)(rhs.ch+32);
10901    return retval;
10902}
10903
10904// --- algo.RnullStr36..Update
10905// Set value. Return true if new value is different from old value.
10906inline bool algo::RnullStr36_Update(algo::RnullStr36 &lhs, algo::RnullStr36& rhs) {
10907    bool ret = !RnullStr36_Eq(lhs, rhs); // compare values
10908    if (ret) {
10909        lhs = rhs; // update
10910    }
10911    return ret;
10912}
10913
10914// --- algo.RnullStr36..EqStrptr
10915inline bool algo::RnullStr36_EqStrptr(const algo::RnullStr36& lhs, const algo::strptr& rhs) {
10916    return algo::strptr_Eq(ch_Getary(lhs), rhs);
10917}
10918inline algo::RnullStr4::RnullStr4() {
10919    algo::RnullStr4_Init(*this);
10920}
10921
10922
10923// --- algo.RnullStr4.ch.Getary
10924// Access string as array of chars
10925inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr4& parent) {
10926    int len = ch_N(parent);
10927    algo::aryptr<char> ret((char*)parent.ch, len);
10928    return ret;
10929}
10930
10931// --- algo.RnullStr4.ch.HashStrptr
10932inline u32 algo::RnullStr4_Hash(u32 prev, const algo::strptr &str) {
10933    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10934}
10935
10936// --- algo.RnullStr4.ch.Init
10937inline void algo::ch_Init(algo::RnullStr4 &parent) {
10938    memset(parent.ch, 0, 4);
10939}
10940
10941// --- algo.RnullStr4.ch.Max
10942// always return constant 4
10943inline int algo::ch_Max(algo::RnullStr4& parent) {
10944    (void)parent;
10945    return 4;
10946}
10947
10948// --- algo.RnullStr4.ch.N
10949inline int algo::ch_N(const algo::RnullStr4& parent) {
10950    u64 ret;
10951    ret = 4;
10952    while (ret>0 && parent.ch[ret-1]==u8(0)) {
10953        ret--;
10954    }
10955    return int(ret);
10956}
10957
10958// --- algo.RnullStr4.ch.AssignStrptr
10959// Copy from strptr (operator=)
10960inline void algo::RnullStr4::operator =(const algo::strptr &str) {
10961    ch_SetStrptr(*this, str);
10962}
10963
10964// --- algo.RnullStr4.ch.Set
10965// Copy from same type
10966// Copy value from RHS.
10967inline void algo::RnullStr4::operator =(const algo::RnullStr4& parent) {
10968    memcpy(ch, parent.ch, 4);
10969}
10970
10971// --- algo.RnullStr4.ch.Ctor
10972inline  algo::RnullStr4::RnullStr4(const algo::RnullStr4 &rhs) {
10973    operator =(rhs);
10974}
10975
10976// --- algo.RnullStr4.ch.CtorStrptr
10977inline  algo::RnullStr4::RnullStr4(const algo::strptr &rhs) {
10978    ch_SetStrptr(*this, rhs);
10979}
10980
10981// --- algo.RnullStr4.ch.Cast
10982inline algo::RnullStr4::operator algo::strptr () const {
10983    return ch_Getary(*this);
10984}
10985
10986// --- algo.RnullStr4..Lt
10987inline bool algo::RnullStr4_Lt(algo::RnullStr4 lhs, algo::RnullStr4 rhs) {
10988    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10989}
10990
10991// --- algo.RnullStr4..Cmp
10992inline i32 algo::RnullStr4_Cmp(algo::RnullStr4 lhs, algo::RnullStr4 rhs) {
10993    i32 retval = 0;
10994    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10995    return retval;
10996}
10997
10998// --- algo.RnullStr4..Init
10999// Set all fields to initial values.
11000inline void algo::RnullStr4_Init(algo::RnullStr4& parent) {
11001    memset(parent.ch, 0, 4);
11002}
11003
11004// --- algo.RnullStr4..Eq
11005inline bool algo::RnullStr4_Eq(algo::RnullStr4 lhs, algo::RnullStr4 rhs) {
11006    bool retval = true;
11007    retval = retval
11008    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
11009    return retval;
11010}
11011
11012// --- algo.RnullStr4..Update
11013// Set value. Return true if new value is different from old value.
11014inline bool algo::RnullStr4_Update(algo::RnullStr4 &lhs, algo::RnullStr4 rhs) {
11015    bool ret = !RnullStr4_Eq(lhs, rhs); // compare values
11016    if (ret) {
11017        lhs = rhs; // update
11018    }
11019    return ret;
11020}
11021
11022// --- algo.RnullStr4..EqStrptr
11023inline bool algo::RnullStr4_EqStrptr(algo::RnullStr4 lhs, const algo::strptr& rhs) {
11024    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11025}
11026
11027inline bool algo::RnullStr40::operator ==(const algo::RnullStr40 &rhs) const {
11028    return algo::RnullStr40_Eq(const_cast<algo::RnullStr40&>(*this),const_cast<algo::RnullStr40&>(rhs));
11029}
11030
11031inline bool algo::RnullStr40::operator !=(const algo::RnullStr40 &rhs) const {
11032    return !algo::RnullStr40_Eq(const_cast<algo::RnullStr40&>(*this),const_cast<algo::RnullStr40&>(rhs));
11033}
11034
11035inline bool algo::RnullStr40::operator ==(const algo::strptr &rhs) const {
11036    return algo::RnullStr40_EqStrptr(const_cast<algo::RnullStr40&>(*this),rhs);
11037}
11038
11039inline bool algo::RnullStr40::operator <(const algo::RnullStr40 &rhs) const {
11040    return algo::RnullStr40_Lt(const_cast<algo::RnullStr40&>(*this),const_cast<algo::RnullStr40&>(rhs));
11041}
11042
11043inline bool algo::RnullStr40::operator >(const algo::RnullStr40 &rhs) const {
11044    return rhs < *this;
11045}
11046
11047inline bool algo::RnullStr40::operator <=(const algo::RnullStr40 &rhs) const {
11048    return !(rhs < *this);
11049}
11050
11051inline bool algo::RnullStr40::operator >=(const algo::RnullStr40 &rhs) const {
11052    return !(*this < rhs);
11053}
11054inline algo::RnullStr40::RnullStr40() {
11055    algo::RnullStr40_Init(*this);
11056}
11057
11058
11059// --- algo.RnullStr40.ch.Getary
11060// Access string as array of chars
11061inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr40& parent) {
11062    int len = ch_N(parent);
11063    algo::aryptr<char> ret((char*)parent.ch, len);
11064    return ret;
11065}
11066
11067// --- algo.RnullStr40.ch.HashStrptr
11068inline u32 algo::RnullStr40_Hash(u32 prev, const algo::strptr &str) {
11069    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11070}
11071
11072// --- algo.RnullStr40.ch.Init
11073inline void algo::ch_Init(algo::RnullStr40 &parent) {
11074    memset(parent.ch, 0, 40);
11075}
11076
11077// --- algo.RnullStr40.ch.Max
11078// always return constant 40
11079inline int algo::ch_Max(algo::RnullStr40& parent) {
11080    (void)parent;
11081    return 40;
11082}
11083
11084// --- algo.RnullStr40.ch.N
11085inline int algo::ch_N(const algo::RnullStr40& parent) {
11086    u64 ret;
11087    ret = 40;
11088    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11089        ret--;
11090    }
11091    return int(ret);
11092}
11093
11094// --- algo.RnullStr40.ch.AssignStrptr
11095// Copy from strptr (operator=)
11096inline void algo::RnullStr40::operator =(const algo::strptr &str) {
11097    ch_SetStrptr(*this, str);
11098}
11099
11100// --- algo.RnullStr40.ch.Set
11101// Copy from same type
11102// Copy value from RHS.
11103inline void algo::RnullStr40::operator =(const algo::RnullStr40& parent) {
11104    memcpy(ch, parent.ch, 40);
11105}
11106
11107// --- algo.RnullStr40.ch.Ctor
11108inline  algo::RnullStr40::RnullStr40(const algo::RnullStr40 &rhs) {
11109    operator =(rhs);
11110}
11111
11112// --- algo.RnullStr40.ch.CtorStrptr
11113inline  algo::RnullStr40::RnullStr40(const algo::strptr &rhs) {
11114    ch_SetStrptr(*this, rhs);
11115}
11116
11117// --- algo.RnullStr40.ch.Cast
11118inline algo::RnullStr40::operator algo::strptr () const {
11119    return ch_Getary(*this);
11120}
11121
11122// --- algo.RnullStr40..Lt
11123inline bool algo::RnullStr40_Lt(algo::RnullStr40& lhs, algo::RnullStr40& rhs) {
11124    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11125}
11126
11127// --- algo.RnullStr40..Cmp
11128inline i32 algo::RnullStr40_Cmp(algo::RnullStr40& lhs, algo::RnullStr40& rhs) {
11129    i32 retval = 0;
11130    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11131    return retval;
11132}
11133
11134// --- algo.RnullStr40..Init
11135// Set all fields to initial values.
11136inline void algo::RnullStr40_Init(algo::RnullStr40& parent) {
11137    memset(parent.ch, 0, 40);
11138}
11139
11140// --- algo.RnullStr40..Eq
11141inline bool algo::RnullStr40_Eq(algo::RnullStr40& lhs, algo::RnullStr40& rhs) {
11142    bool retval = true;
11143    retval = retval
11144    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11145    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11146    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11147    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11148    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32);
11149    return retval;
11150}
11151
11152// --- algo.RnullStr40..Update
11153// Set value. Return true if new value is different from old value.
11154inline bool algo::RnullStr40_Update(algo::RnullStr40 &lhs, algo::RnullStr40& rhs) {
11155    bool ret = !RnullStr40_Eq(lhs, rhs); // compare values
11156    if (ret) {
11157        lhs = rhs; // update
11158    }
11159    return ret;
11160}
11161
11162// --- algo.RnullStr40..EqStrptr
11163inline bool algo::RnullStr40_EqStrptr(const algo::RnullStr40& lhs, const algo::strptr& rhs) {
11164    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11165}
11166
11167inline bool algo::RnullStr41::operator ==(const algo::RnullStr41 &rhs) const {
11168    return algo::RnullStr41_Eq(const_cast<algo::RnullStr41&>(*this),const_cast<algo::RnullStr41&>(rhs));
11169}
11170
11171inline bool algo::RnullStr41::operator !=(const algo::RnullStr41 &rhs) const {
11172    return !algo::RnullStr41_Eq(const_cast<algo::RnullStr41&>(*this),const_cast<algo::RnullStr41&>(rhs));
11173}
11174
11175inline bool algo::RnullStr41::operator ==(const algo::strptr &rhs) const {
11176    return algo::RnullStr41_EqStrptr(const_cast<algo::RnullStr41&>(*this),rhs);
11177}
11178
11179inline bool algo::RnullStr41::operator <(const algo::RnullStr41 &rhs) const {
11180    return algo::RnullStr41_Lt(const_cast<algo::RnullStr41&>(*this),const_cast<algo::RnullStr41&>(rhs));
11181}
11182
11183inline bool algo::RnullStr41::operator >(const algo::RnullStr41 &rhs) const {
11184    return rhs < *this;
11185}
11186
11187inline bool algo::RnullStr41::operator <=(const algo::RnullStr41 &rhs) const {
11188    return !(rhs < *this);
11189}
11190
11191inline bool algo::RnullStr41::operator >=(const algo::RnullStr41 &rhs) const {
11192    return !(*this < rhs);
11193}
11194inline algo::RnullStr41::RnullStr41() {
11195    algo::RnullStr41_Init(*this);
11196}
11197
11198
11199// --- algo.RnullStr41.ch.Getary
11200// Access string as array of chars
11201inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr41& parent) {
11202    int len = ch_N(parent);
11203    algo::aryptr<char> ret((char*)parent.ch, len);
11204    return ret;
11205}
11206
11207// --- algo.RnullStr41.ch.HashStrptr
11208inline u32 algo::RnullStr41_Hash(u32 prev, const algo::strptr &str) {
11209    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11210}
11211
11212// --- algo.RnullStr41.ch.Init
11213inline void algo::ch_Init(algo::RnullStr41 &parent) {
11214    memset(parent.ch, 0, 41);
11215}
11216
11217// --- algo.RnullStr41.ch.Max
11218// always return constant 41
11219inline int algo::ch_Max(algo::RnullStr41& parent) {
11220    (void)parent;
11221    return 41;
11222}
11223
11224// --- algo.RnullStr41.ch.N
11225inline int algo::ch_N(const algo::RnullStr41& parent) {
11226    u64 ret;
11227    ret = 41;
11228    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11229        ret--;
11230    }
11231    return int(ret);
11232}
11233
11234// --- algo.RnullStr41.ch.AssignStrptr
11235// Copy from strptr (operator=)
11236inline void algo::RnullStr41::operator =(const algo::strptr &str) {
11237    ch_SetStrptr(*this, str);
11238}
11239
11240// --- algo.RnullStr41.ch.Set
11241// Copy from same type
11242// Copy value from RHS.
11243inline void algo::RnullStr41::operator =(const algo::RnullStr41& parent) {
11244    memcpy(ch, parent.ch, 41);
11245}
11246
11247// --- algo.RnullStr41.ch.Ctor
11248inline  algo::RnullStr41::RnullStr41(const algo::RnullStr41 &rhs) {
11249    operator =(rhs);
11250}
11251
11252// --- algo.RnullStr41.ch.CtorStrptr
11253inline  algo::RnullStr41::RnullStr41(const algo::strptr &rhs) {
11254    ch_SetStrptr(*this, rhs);
11255}
11256
11257// --- algo.RnullStr41.ch.Cast
11258inline algo::RnullStr41::operator algo::strptr () const {
11259    return ch_Getary(*this);
11260}
11261
11262// --- algo.RnullStr41..Lt
11263inline bool algo::RnullStr41_Lt(algo::RnullStr41& lhs, algo::RnullStr41& rhs) {
11264    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11265}
11266
11267// --- algo.RnullStr41..Cmp
11268inline i32 algo::RnullStr41_Cmp(algo::RnullStr41& lhs, algo::RnullStr41& rhs) {
11269    i32 retval = 0;
11270    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11271    return retval;
11272}
11273
11274// --- algo.RnullStr41..Init
11275// Set all fields to initial values.
11276inline void algo::RnullStr41_Init(algo::RnullStr41& parent) {
11277    memset(parent.ch, 0, 41);
11278}
11279
11280// --- algo.RnullStr41..Eq
11281inline bool algo::RnullStr41_Eq(algo::RnullStr41& lhs, algo::RnullStr41& rhs) {
11282    bool retval = true;
11283    retval = retval
11284    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11285    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11286    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11287    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11288    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11289    &&*(u8*)(lhs.ch+40) == *(u8*)(rhs.ch+40);
11290    return retval;
11291}
11292
11293// --- algo.RnullStr41..Update
11294// Set value. Return true if new value is different from old value.
11295inline bool algo::RnullStr41_Update(algo::RnullStr41 &lhs, algo::RnullStr41& rhs) {
11296    bool ret = !RnullStr41_Eq(lhs, rhs); // compare values
11297    if (ret) {
11298        lhs = rhs; // update
11299    }
11300    return ret;
11301}
11302
11303// --- algo.RnullStr41..EqStrptr
11304inline bool algo::RnullStr41_EqStrptr(const algo::RnullStr41& lhs, const algo::strptr& rhs) {
11305    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11306}
11307inline algo::RnullStr43::RnullStr43() {
11308    algo::RnullStr43_Init(*this);
11309}
11310
11311
11312// --- algo.RnullStr43.ch.Getary
11313// Access string as array of chars
11314inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr43& parent) {
11315    int len = ch_N(parent);
11316    algo::aryptr<char> ret((char*)parent.ch, len);
11317    return ret;
11318}
11319
11320// --- algo.RnullStr43.ch.HashStrptr
11321inline u32 algo::RnullStr43_Hash(u32 prev, const algo::strptr &str) {
11322    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11323}
11324
11325// --- algo.RnullStr43.ch.Init
11326inline void algo::ch_Init(algo::RnullStr43 &parent) {
11327    memset(parent.ch, 0, 43);
11328}
11329
11330// --- algo.RnullStr43.ch.Max
11331// always return constant 43
11332inline int algo::ch_Max(algo::RnullStr43& parent) {
11333    (void)parent;
11334    return 43;
11335}
11336
11337// --- algo.RnullStr43.ch.N
11338inline int algo::ch_N(const algo::RnullStr43& parent) {
11339    u64 ret;
11340    ret = 43;
11341    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11342        ret--;
11343    }
11344    return int(ret);
11345}
11346
11347// --- algo.RnullStr43.ch.AssignStrptr
11348// Copy from strptr (operator=)
11349inline void algo::RnullStr43::operator =(const algo::strptr &str) {
11350    ch_SetStrptr(*this, str);
11351}
11352
11353// --- algo.RnullStr43.ch.Set
11354// Copy from same type
11355// Copy value from RHS.
11356inline void algo::RnullStr43::operator =(const algo::RnullStr43& parent) {
11357    memcpy(ch, parent.ch, 43);
11358}
11359
11360// --- algo.RnullStr43.ch.Ctor
11361inline  algo::RnullStr43::RnullStr43(const algo::RnullStr43 &rhs) {
11362    operator =(rhs);
11363}
11364
11365// --- algo.RnullStr43.ch.CtorStrptr
11366inline  algo::RnullStr43::RnullStr43(const algo::strptr &rhs) {
11367    ch_SetStrptr(*this, rhs);
11368}
11369
11370// --- algo.RnullStr43.ch.Cast
11371inline algo::RnullStr43::operator algo::strptr () const {
11372    return ch_Getary(*this);
11373}
11374
11375// --- algo.RnullStr43..Lt
11376inline bool algo::RnullStr43_Lt(algo::RnullStr43& lhs, algo::RnullStr43& rhs) {
11377    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11378}
11379
11380// --- algo.RnullStr43..Cmp
11381inline i32 algo::RnullStr43_Cmp(algo::RnullStr43& lhs, algo::RnullStr43& rhs) {
11382    i32 retval = 0;
11383    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11384    return retval;
11385}
11386
11387// --- algo.RnullStr43..Init
11388// Set all fields to initial values.
11389inline void algo::RnullStr43_Init(algo::RnullStr43& parent) {
11390    memset(parent.ch, 0, 43);
11391}
11392
11393// --- algo.RnullStr43..Eq
11394inline bool algo::RnullStr43_Eq(algo::RnullStr43& lhs, algo::RnullStr43& rhs) {
11395    bool retval = true;
11396    retval = retval
11397    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11398    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11399    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11400    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11401    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11402    &&*(u16*)(lhs.ch+40) == *(u16*)(rhs.ch+40)
11403    &&*(u8*)(lhs.ch+42) == *(u8*)(rhs.ch+42);
11404    return retval;
11405}
11406
11407// --- algo.RnullStr43..Update
11408// Set value. Return true if new value is different from old value.
11409inline bool algo::RnullStr43_Update(algo::RnullStr43 &lhs, algo::RnullStr43& rhs) {
11410    bool ret = !RnullStr43_Eq(lhs, rhs); // compare values
11411    if (ret) {
11412        lhs = rhs; // update
11413    }
11414    return ret;
11415}
11416
11417// --- algo.RnullStr43..EqStrptr
11418inline bool algo::RnullStr43_EqStrptr(const algo::RnullStr43& lhs, const algo::strptr& rhs) {
11419    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11420}
11421inline algo::RnullStr44::RnullStr44() {
11422    algo::RnullStr44_Init(*this);
11423}
11424
11425
11426// --- algo.RnullStr44.ch.Getary
11427// Access string as array of chars
11428inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr44& parent) {
11429    int len = ch_N(parent);
11430    algo::aryptr<char> ret((char*)parent.ch, len);
11431    return ret;
11432}
11433
11434// --- algo.RnullStr44.ch.HashStrptr
11435inline u32 algo::RnullStr44_Hash(u32 prev, const algo::strptr &str) {
11436    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11437}
11438
11439// --- algo.RnullStr44.ch.Init
11440inline void algo::ch_Init(algo::RnullStr44 &parent) {
11441    memset(parent.ch, 0, 44);
11442}
11443
11444// --- algo.RnullStr44.ch.Max
11445// always return constant 44
11446inline int algo::ch_Max(algo::RnullStr44& parent) {
11447    (void)parent;
11448    return 44;
11449}
11450
11451// --- algo.RnullStr44.ch.N
11452inline int algo::ch_N(const algo::RnullStr44& parent) {
11453    u64 ret;
11454    ret = 44;
11455    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11456        ret--;
11457    }
11458    return int(ret);
11459}
11460
11461// --- algo.RnullStr44.ch.AssignStrptr
11462// Copy from strptr (operator=)
11463inline void algo::RnullStr44::operator =(const algo::strptr &str) {
11464    ch_SetStrptr(*this, str);
11465}
11466
11467// --- algo.RnullStr44.ch.Set
11468// Copy from same type
11469// Copy value from RHS.
11470inline void algo::RnullStr44::operator =(const algo::RnullStr44& parent) {
11471    memcpy(ch, parent.ch, 44);
11472}
11473
11474// --- algo.RnullStr44.ch.Ctor
11475inline  algo::RnullStr44::RnullStr44(const algo::RnullStr44 &rhs) {
11476    operator =(rhs);
11477}
11478
11479// --- algo.RnullStr44.ch.CtorStrptr
11480inline  algo::RnullStr44::RnullStr44(const algo::strptr &rhs) {
11481    ch_SetStrptr(*this, rhs);
11482}
11483
11484// --- algo.RnullStr44.ch.Cast
11485inline algo::RnullStr44::operator algo::strptr () const {
11486    return ch_Getary(*this);
11487}
11488
11489// --- algo.RnullStr44..Lt
11490inline bool algo::RnullStr44_Lt(algo::RnullStr44& lhs, algo::RnullStr44& rhs) {
11491    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11492}
11493
11494// --- algo.RnullStr44..Cmp
11495inline i32 algo::RnullStr44_Cmp(algo::RnullStr44& lhs, algo::RnullStr44& rhs) {
11496    i32 retval = 0;
11497    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11498    return retval;
11499}
11500
11501// --- algo.RnullStr44..Init
11502// Set all fields to initial values.
11503inline void algo::RnullStr44_Init(algo::RnullStr44& parent) {
11504    memset(parent.ch, 0, 44);
11505}
11506
11507// --- algo.RnullStr44..Eq
11508inline bool algo::RnullStr44_Eq(algo::RnullStr44& lhs, algo::RnullStr44& rhs) {
11509    bool retval = true;
11510    retval = retval
11511    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11512    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11513    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11514    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11515    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11516    &&*(u32*)(lhs.ch+40) == *(u32*)(rhs.ch+40);
11517    return retval;
11518}
11519
11520// --- algo.RnullStr44..Update
11521// Set value. Return true if new value is different from old value.
11522inline bool algo::RnullStr44_Update(algo::RnullStr44 &lhs, algo::RnullStr44& rhs) {
11523    bool ret = !RnullStr44_Eq(lhs, rhs); // compare values
11524    if (ret) {
11525        lhs = rhs; // update
11526    }
11527    return ret;
11528}
11529
11530// --- algo.RnullStr44..EqStrptr
11531inline bool algo::RnullStr44_EqStrptr(const algo::RnullStr44& lhs, const algo::strptr& rhs) {
11532    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11533}
11534inline algo::RnullStr48::RnullStr48() {
11535    algo::RnullStr48_Init(*this);
11536}
11537
11538
11539// --- algo.RnullStr48.ch.Getary
11540// Access string as array of chars
11541inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr48& parent) {
11542    int len = ch_N(parent);
11543    algo::aryptr<char> ret((char*)parent.ch, len);
11544    return ret;
11545}
11546
11547// --- algo.RnullStr48.ch.HashStrptr
11548inline u32 algo::RnullStr48_Hash(u32 prev, const algo::strptr &str) {
11549    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11550}
11551
11552// --- algo.RnullStr48.ch.Init
11553inline void algo::ch_Init(algo::RnullStr48 &parent) {
11554    memset(parent.ch, 0, 48);
11555}
11556
11557// --- algo.RnullStr48.ch.Max
11558// always return constant 48
11559inline int algo::ch_Max(algo::RnullStr48& parent) {
11560    (void)parent;
11561    return 48;
11562}
11563
11564// --- algo.RnullStr48.ch.N
11565inline int algo::ch_N(const algo::RnullStr48& parent) {
11566    u64 ret;
11567    ret = 48;
11568    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11569        ret--;
11570    }
11571    return int(ret);
11572}
11573
11574// --- algo.RnullStr48.ch.AssignStrptr
11575// Copy from strptr (operator=)
11576inline void algo::RnullStr48::operator =(const algo::strptr &str) {
11577    ch_SetStrptr(*this, str);
11578}
11579
11580// --- algo.RnullStr48.ch.Set
11581// Copy from same type
11582// Copy value from RHS.
11583inline void algo::RnullStr48::operator =(const algo::RnullStr48& parent) {
11584    memcpy(ch, parent.ch, 48);
11585}
11586
11587// --- algo.RnullStr48.ch.Ctor
11588inline  algo::RnullStr48::RnullStr48(const algo::RnullStr48 &rhs) {
11589    operator =(rhs);
11590}
11591
11592// --- algo.RnullStr48.ch.CtorStrptr
11593inline  algo::RnullStr48::RnullStr48(const algo::strptr &rhs) {
11594    ch_SetStrptr(*this, rhs);
11595}
11596
11597// --- algo.RnullStr48.ch.Cast
11598inline algo::RnullStr48::operator algo::strptr () const {
11599    return ch_Getary(*this);
11600}
11601
11602// --- algo.RnullStr48..Lt
11603inline bool algo::RnullStr48_Lt(algo::RnullStr48& lhs, algo::RnullStr48& rhs) {
11604    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11605}
11606
11607// --- algo.RnullStr48..Cmp
11608inline i32 algo::RnullStr48_Cmp(algo::RnullStr48& lhs, algo::RnullStr48& rhs) {
11609    i32 retval = 0;
11610    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11611    return retval;
11612}
11613
11614// --- algo.RnullStr48..Init
11615// Set all fields to initial values.
11616inline void algo::RnullStr48_Init(algo::RnullStr48& parent) {
11617    memset(parent.ch, 0, 48);
11618}
11619
11620// --- algo.RnullStr48..Eq
11621inline bool algo::RnullStr48_Eq(algo::RnullStr48& lhs, algo::RnullStr48& rhs) {
11622    bool retval = true;
11623    retval = retval
11624    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11625    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11626    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11627    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11628    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11629    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40);
11630    return retval;
11631}
11632
11633// --- algo.RnullStr48..Update
11634// Set value. Return true if new value is different from old value.
11635inline bool algo::RnullStr48_Update(algo::RnullStr48 &lhs, algo::RnullStr48& rhs) {
11636    bool ret = !RnullStr48_Eq(lhs, rhs); // compare values
11637    if (ret) {
11638        lhs = rhs; // update
11639    }
11640    return ret;
11641}
11642
11643// --- algo.RnullStr48..EqStrptr
11644inline bool algo::RnullStr48_EqStrptr(const algo::RnullStr48& lhs, const algo::strptr& rhs) {
11645    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11646}
11647inline algo::RnullStr5::RnullStr5() {
11648    algo::RnullStr5_Init(*this);
11649}
11650
11651
11652// --- algo.RnullStr5.ch.Getary
11653// Access string as array of chars
11654inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr5& parent) {
11655    int len = ch_N(parent);
11656    algo::aryptr<char> ret((char*)parent.ch, len);
11657    return ret;
11658}
11659
11660// --- algo.RnullStr5.ch.HashStrptr
11661inline u32 algo::RnullStr5_Hash(u32 prev, const algo::strptr &str) {
11662    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11663}
11664
11665// --- algo.RnullStr5.ch.Init
11666inline void algo::ch_Init(algo::RnullStr5 &parent) {
11667    memset(parent.ch, 0, 5);
11668}
11669
11670// --- algo.RnullStr5.ch.Max
11671// always return constant 5
11672inline int algo::ch_Max(algo::RnullStr5& parent) {
11673    (void)parent;
11674    return 5;
11675}
11676
11677// --- algo.RnullStr5.ch.N
11678inline int algo::ch_N(const algo::RnullStr5& parent) {
11679    u64 ret;
11680    ret = 5;
11681    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11682        ret--;
11683    }
11684    return int(ret);
11685}
11686
11687// --- algo.RnullStr5.ch.AssignStrptr
11688// Copy from strptr (operator=)
11689inline void algo::RnullStr5::operator =(const algo::strptr &str) {
11690    ch_SetStrptr(*this, str);
11691}
11692
11693// --- algo.RnullStr5.ch.Set
11694// Copy from same type
11695// Copy value from RHS.
11696inline void algo::RnullStr5::operator =(const algo::RnullStr5& parent) {
11697    memcpy(ch, parent.ch, 5);
11698}
11699
11700// --- algo.RnullStr5.ch.Ctor
11701inline  algo::RnullStr5::RnullStr5(const algo::RnullStr5 &rhs) {
11702    operator =(rhs);
11703}
11704
11705// --- algo.RnullStr5.ch.CtorStrptr
11706inline  algo::RnullStr5::RnullStr5(const algo::strptr &rhs) {
11707    ch_SetStrptr(*this, rhs);
11708}
11709
11710// --- algo.RnullStr5.ch.Cast
11711inline algo::RnullStr5::operator algo::strptr () const {
11712    return ch_Getary(*this);
11713}
11714
11715// --- algo.RnullStr5..Lt
11716inline bool algo::RnullStr5_Lt(algo::RnullStr5 lhs, algo::RnullStr5 rhs) {
11717    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11718}
11719
11720// --- algo.RnullStr5..Cmp
11721inline i32 algo::RnullStr5_Cmp(algo::RnullStr5 lhs, algo::RnullStr5 rhs) {
11722    i32 retval = 0;
11723    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11724    return retval;
11725}
11726
11727// --- algo.RnullStr5..Init
11728// Set all fields to initial values.
11729inline void algo::RnullStr5_Init(algo::RnullStr5& parent) {
11730    memset(parent.ch, 0, 5);
11731}
11732
11733// --- algo.RnullStr5..Eq
11734inline bool algo::RnullStr5_Eq(algo::RnullStr5 lhs, algo::RnullStr5 rhs) {
11735    bool retval = true;
11736    retval = retval
11737    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
11738    &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
11739    return retval;
11740}
11741
11742// --- algo.RnullStr5..Update
11743// Set value. Return true if new value is different from old value.
11744inline bool algo::RnullStr5_Update(algo::RnullStr5 &lhs, algo::RnullStr5 rhs) {
11745    bool ret = !RnullStr5_Eq(lhs, rhs); // compare values
11746    if (ret) {
11747        lhs = rhs; // update
11748    }
11749    return ret;
11750}
11751
11752// --- algo.RnullStr5..EqStrptr
11753inline bool algo::RnullStr5_EqStrptr(algo::RnullStr5 lhs, const algo::strptr& rhs) {
11754    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11755}
11756inline algo::RnullStr50::RnullStr50() {
11757    algo::RnullStr50_Init(*this);
11758}
11759
11760
11761// --- algo.RnullStr50.ch.Getary
11762// Access string as array of chars
11763inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr50& parent) {
11764    int len = ch_N(parent);
11765    algo::aryptr<char> ret((char*)parent.ch, len);
11766    return ret;
11767}
11768
11769// --- algo.RnullStr50.ch.HashStrptr
11770inline u32 algo::RnullStr50_Hash(u32 prev, const algo::strptr &str) {
11771    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11772}
11773
11774// --- algo.RnullStr50.ch.Init
11775inline void algo::ch_Init(algo::RnullStr50 &parent) {
11776    memset(parent.ch, 0, 50);
11777}
11778
11779// --- algo.RnullStr50.ch.Max
11780// always return constant 50
11781inline int algo::ch_Max(algo::RnullStr50& parent) {
11782    (void)parent;
11783    return 50;
11784}
11785
11786// --- algo.RnullStr50.ch.N
11787inline int algo::ch_N(const algo::RnullStr50& parent) {
11788    u64 ret;
11789    ret = 50;
11790    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11791        ret--;
11792    }
11793    return int(ret);
11794}
11795
11796// --- algo.RnullStr50.ch.AssignStrptr
11797// Copy from strptr (operator=)
11798inline void algo::RnullStr50::operator =(const algo::strptr &str) {
11799    ch_SetStrptr(*this, str);
11800}
11801
11802// --- algo.RnullStr50.ch.Set
11803// Copy from same type
11804// Copy value from RHS.
11805inline void algo::RnullStr50::operator =(const algo::RnullStr50& parent) {
11806    memcpy(ch, parent.ch, 50);
11807}
11808
11809// --- algo.RnullStr50.ch.Ctor
11810inline  algo::RnullStr50::RnullStr50(const algo::RnullStr50 &rhs) {
11811    operator =(rhs);
11812}
11813
11814// --- algo.RnullStr50.ch.CtorStrptr
11815inline  algo::RnullStr50::RnullStr50(const algo::strptr &rhs) {
11816    ch_SetStrptr(*this, rhs);
11817}
11818
11819// --- algo.RnullStr50.ch.Cast
11820inline algo::RnullStr50::operator algo::strptr () const {
11821    return ch_Getary(*this);
11822}
11823
11824// --- algo.RnullStr50..Lt
11825inline bool algo::RnullStr50_Lt(algo::RnullStr50& lhs, algo::RnullStr50& rhs) {
11826    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11827}
11828
11829// --- algo.RnullStr50..Cmp
11830inline i32 algo::RnullStr50_Cmp(algo::RnullStr50& lhs, algo::RnullStr50& rhs) {
11831    i32 retval = 0;
11832    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11833    return retval;
11834}
11835
11836// --- algo.RnullStr50..Init
11837// Set all fields to initial values.
11838inline void algo::RnullStr50_Init(algo::RnullStr50& parent) {
11839    memset(parent.ch, 0, 50);
11840}
11841
11842// --- algo.RnullStr50..Eq
11843inline bool algo::RnullStr50_Eq(algo::RnullStr50& lhs, algo::RnullStr50& rhs) {
11844    bool retval = true;
11845    retval = retval
11846    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11847    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11848    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11849    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11850    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11851    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
11852    &&*(u16*)(lhs.ch+48) == *(u16*)(rhs.ch+48);
11853    return retval;
11854}
11855
11856// --- algo.RnullStr50..Update
11857// Set value. Return true if new value is different from old value.
11858inline bool algo::RnullStr50_Update(algo::RnullStr50 &lhs, algo::RnullStr50& rhs) {
11859    bool ret = !RnullStr50_Eq(lhs, rhs); // compare values
11860    if (ret) {
11861        lhs = rhs; // update
11862    }
11863    return ret;
11864}
11865
11866// --- algo.RnullStr50..EqStrptr
11867inline bool algo::RnullStr50_EqStrptr(const algo::RnullStr50& lhs, const algo::strptr& rhs) {
11868    return algo::strptr_Eq(ch_Getary(lhs), rhs);
11869}
11870
11871inline bool algo::RnullStr54::operator ==(const algo::RnullStr54 &rhs) const {
11872    return algo::RnullStr54_Eq(const_cast<algo::RnullStr54&>(*this),const_cast<algo::RnullStr54&>(rhs));
11873}
11874
11875inline bool algo::RnullStr54::operator !=(const algo::RnullStr54 &rhs) const {
11876    return !algo::RnullStr54_Eq(const_cast<algo::RnullStr54&>(*this),const_cast<algo::RnullStr54&>(rhs));
11877}
11878
11879inline bool algo::RnullStr54::operator ==(const algo::strptr &rhs) const {
11880    return algo::RnullStr54_EqStrptr(const_cast<algo::RnullStr54&>(*this),rhs);
11881}
11882
11883inline bool algo::RnullStr54::operator <(const algo::RnullStr54 &rhs) const {
11884    return algo::RnullStr54_Lt(const_cast<algo::RnullStr54&>(*this),const_cast<algo::RnullStr54&>(rhs));
11885}
11886
11887inline bool algo::RnullStr54::operator >(const algo::RnullStr54 &rhs) const {
11888    return rhs < *this;
11889}
11890
11891inline bool algo::RnullStr54::operator <=(const algo::RnullStr54 &rhs) const {
11892    return !(rhs < *this);
11893}
11894
11895inline bool algo::RnullStr54::operator >=(const algo::RnullStr54 &rhs) const {
11896    return !(*this < rhs);
11897}
11898inline algo::RnullStr54::RnullStr54() {
11899    algo::RnullStr54_Init(*this);
11900}
11901
11902
11903// --- algo.RnullStr54.ch.Getary
11904// Access string as array of chars
11905inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr54& parent) {
11906    int len = ch_N(parent);
11907    algo::aryptr<char> ret((char*)parent.ch, len);
11908    return ret;
11909}
11910
11911// --- algo.RnullStr54.ch.HashStrptr
11912inline u32 algo::RnullStr54_Hash(u32 prev, const algo::strptr &str) {
11913    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11914}
11915
11916// --- algo.RnullStr54.ch.Init
11917inline void algo::ch_Init(algo::RnullStr54 &parent) {
11918    memset(parent.ch, 0, 54);
11919}
11920
11921// --- algo.RnullStr54.ch.Max
11922// always return constant 54
11923inline int algo::ch_Max(algo::RnullStr54& parent) {
11924    (void)parent;
11925    return 54;
11926}
11927
11928// --- algo.RnullStr54.ch.N
11929inline int algo::ch_N(const algo::RnullStr54& parent) {
11930    u64 ret;
11931    ret = 54;
11932    while (ret>0 && parent.ch[ret-1]==u8(0)) {
11933        ret--;
11934    }
11935    return int(ret);
11936}
11937
11938// --- algo.RnullStr54.ch.AssignStrptr
11939// Copy from strptr (operator=)
11940inline void algo::RnullStr54::operator =(const algo::strptr &str) {
11941    ch_SetStrptr(*this, str);
11942}
11943
11944// --- algo.RnullStr54.ch.Set
11945// Copy from same type
11946// Copy value from RHS.
11947inline void algo::RnullStr54::operator =(const algo::RnullStr54& parent) {
11948    memcpy(ch, parent.ch, 54);
11949}
11950
11951// --- algo.RnullStr54.ch.Ctor
11952inline  algo::RnullStr54::RnullStr54(const algo::RnullStr54 &rhs) {
11953    operator =(rhs);
11954}
11955
11956// --- algo.RnullStr54.ch.CtorStrptr
11957inline  algo::RnullStr54::RnullStr54(const algo::strptr &rhs) {
11958    ch_SetStrptr(*this, rhs);
11959}
11960
11961// --- algo.RnullStr54.ch.Cast
11962inline algo::RnullStr54::operator algo::strptr () const {
11963    return ch_Getary(*this);
11964}
11965
11966// --- algo.RnullStr54..Lt
11967inline bool algo::RnullStr54_Lt(algo::RnullStr54& lhs, algo::RnullStr54& rhs) {
11968    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11969}
11970
11971// --- algo.RnullStr54..Cmp
11972inline i32 algo::RnullStr54_Cmp(algo::RnullStr54& lhs, algo::RnullStr54& rhs) {
11973    i32 retval = 0;
11974    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11975    return retval;
11976}
11977
11978// --- algo.RnullStr54..Init
11979// Set all fields to initial values.
11980inline void algo::RnullStr54_Init(algo::RnullStr54& parent) {
11981    memset(parent.ch, 0, 54);
11982}
11983
11984// --- algo.RnullStr54..Eq
11985inline bool algo::RnullStr54_Eq(algo::RnullStr54& lhs, algo::RnullStr54& rhs) {
11986    bool retval = true;
11987    retval = retval
11988    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11989    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11990    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11991    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11992    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11993    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
11994    &&*(u32*)(lhs.ch+48) == *(u32*)(rhs.ch+48)
11995    &&*(u16*)(lhs.ch+52) == *(u16*)(rhs.ch+52);
11996    return retval;
11997}
11998
11999// --- algo.RnullStr54..Update
12000// Set value. Return true if new value is different from old value.
12001inline bool algo::RnullStr54_Update(algo::RnullStr54 &lhs, algo::RnullStr54& rhs) {
12002    bool ret = !RnullStr54_Eq(lhs, rhs); // compare values
12003    if (ret) {
12004        lhs = rhs; // update
12005    }
12006    return ret;
12007}
12008
12009// --- algo.RnullStr54..EqStrptr
12010inline bool algo::RnullStr54_EqStrptr(const algo::RnullStr54& lhs, const algo::strptr& rhs) {
12011    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12012}
12013inline algo::RnullStr55::RnullStr55() {
12014    algo::RnullStr55_Init(*this);
12015}
12016
12017
12018// --- algo.RnullStr55.ch.Getary
12019// Access string as array of chars
12020inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr55& parent) {
12021    int len = ch_N(parent);
12022    algo::aryptr<char> ret((char*)parent.ch, len);
12023    return ret;
12024}
12025
12026// --- algo.RnullStr55.ch.HashStrptr
12027inline u32 algo::RnullStr55_Hash(u32 prev, const algo::strptr &str) {
12028    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12029}
12030
12031// --- algo.RnullStr55.ch.Init
12032inline void algo::ch_Init(algo::RnullStr55 &parent) {
12033    memset(parent.ch, 0, 55);
12034}
12035
12036// --- algo.RnullStr55.ch.Max
12037// always return constant 55
12038inline int algo::ch_Max(algo::RnullStr55& parent) {
12039    (void)parent;
12040    return 55;
12041}
12042
12043// --- algo.RnullStr55.ch.N
12044inline int algo::ch_N(const algo::RnullStr55& parent) {
12045    u64 ret;
12046    ret = 55;
12047    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12048        ret--;
12049    }
12050    return int(ret);
12051}
12052
12053// --- algo.RnullStr55.ch.AssignStrptr
12054// Copy from strptr (operator=)
12055inline void algo::RnullStr55::operator =(const algo::strptr &str) {
12056    ch_SetStrptr(*this, str);
12057}
12058
12059// --- algo.RnullStr55.ch.Set
12060// Copy from same type
12061// Copy value from RHS.
12062inline void algo::RnullStr55::operator =(const algo::RnullStr55& parent) {
12063    memcpy(ch, parent.ch, 55);
12064}
12065
12066// --- algo.RnullStr55.ch.Ctor
12067inline  algo::RnullStr55::RnullStr55(const algo::RnullStr55 &rhs) {
12068    operator =(rhs);
12069}
12070
12071// --- algo.RnullStr55.ch.CtorStrptr
12072inline  algo::RnullStr55::RnullStr55(const algo::strptr &rhs) {
12073    ch_SetStrptr(*this, rhs);
12074}
12075
12076// --- algo.RnullStr55.ch.Cast
12077inline algo::RnullStr55::operator algo::strptr () const {
12078    return ch_Getary(*this);
12079}
12080
12081// --- algo.RnullStr55..Lt
12082inline bool algo::RnullStr55_Lt(algo::RnullStr55& lhs, algo::RnullStr55& rhs) {
12083    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12084}
12085
12086// --- algo.RnullStr55..Cmp
12087inline i32 algo::RnullStr55_Cmp(algo::RnullStr55& lhs, algo::RnullStr55& rhs) {
12088    i32 retval = 0;
12089    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12090    return retval;
12091}
12092
12093// --- algo.RnullStr55..Init
12094// Set all fields to initial values.
12095inline void algo::RnullStr55_Init(algo::RnullStr55& parent) {
12096    memset(parent.ch, 0, 55);
12097}
12098
12099// --- algo.RnullStr55..Eq
12100inline bool algo::RnullStr55_Eq(algo::RnullStr55& lhs, algo::RnullStr55& rhs) {
12101    bool retval = true;
12102    retval = retval
12103    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12104    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12105    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12106    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12107    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12108    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12109    &&*(u32*)(lhs.ch+48) == *(u32*)(rhs.ch+48)
12110    &&*(u16*)(lhs.ch+52) == *(u16*)(rhs.ch+52)
12111    &&*(u8*)(lhs.ch+54) == *(u8*)(rhs.ch+54);
12112    return retval;
12113}
12114
12115// --- algo.RnullStr55..Update
12116// Set value. Return true if new value is different from old value.
12117inline bool algo::RnullStr55_Update(algo::RnullStr55 &lhs, algo::RnullStr55& rhs) {
12118    bool ret = !RnullStr55_Eq(lhs, rhs); // compare values
12119    if (ret) {
12120        lhs = rhs; // update
12121    }
12122    return ret;
12123}
12124
12125// --- algo.RnullStr55..EqStrptr
12126inline bool algo::RnullStr55_EqStrptr(const algo::RnullStr55& lhs, const algo::strptr& rhs) {
12127    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12128}
12129
12130inline bool algo::RnullStr6::operator ==(const algo::RnullStr6 &rhs) const {
12131    return algo::RnullStr6_Eq(const_cast<algo::RnullStr6&>(*this),const_cast<algo::RnullStr6&>(rhs));
12132}
12133
12134inline bool algo::RnullStr6::operator !=(const algo::RnullStr6 &rhs) const {
12135    return !algo::RnullStr6_Eq(const_cast<algo::RnullStr6&>(*this),const_cast<algo::RnullStr6&>(rhs));
12136}
12137
12138inline bool algo::RnullStr6::operator ==(const algo::strptr &rhs) const {
12139    return algo::RnullStr6_EqStrptr(const_cast<algo::RnullStr6&>(*this),rhs);
12140}
12141
12142inline bool algo::RnullStr6::operator <(const algo::RnullStr6 &rhs) const {
12143    return algo::RnullStr6_Lt(const_cast<algo::RnullStr6&>(*this),const_cast<algo::RnullStr6&>(rhs));
12144}
12145
12146inline bool algo::RnullStr6::operator >(const algo::RnullStr6 &rhs) const {
12147    return rhs < *this;
12148}
12149
12150inline bool algo::RnullStr6::operator <=(const algo::RnullStr6 &rhs) const {
12151    return !(rhs < *this);
12152}
12153
12154inline bool algo::RnullStr6::operator >=(const algo::RnullStr6 &rhs) const {
12155    return !(*this < rhs);
12156}
12157inline algo::RnullStr6::RnullStr6() {
12158    algo::RnullStr6_Init(*this);
12159}
12160
12161
12162// --- algo.RnullStr6.ch.Getary
12163// Access string as array of chars
12164inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr6& parent) {
12165    int len = ch_N(parent);
12166    algo::aryptr<char> ret((char*)parent.ch, len);
12167    return ret;
12168}
12169
12170// --- algo.RnullStr6.ch.HashStrptr
12171inline u32 algo::RnullStr6_Hash(u32 prev, const algo::strptr &str) {
12172    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12173}
12174
12175// --- algo.RnullStr6.ch.Init
12176inline void algo::ch_Init(algo::RnullStr6 &parent) {
12177    memset(parent.ch, 0, 6);
12178}
12179
12180// --- algo.RnullStr6.ch.Max
12181// always return constant 6
12182inline int algo::ch_Max(algo::RnullStr6& parent) {
12183    (void)parent;
12184    return 6;
12185}
12186
12187// --- algo.RnullStr6.ch.N
12188inline int algo::ch_N(const algo::RnullStr6& parent) {
12189    u64 ret;
12190    ret = 6;
12191    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12192        ret--;
12193    }
12194    return int(ret);
12195}
12196
12197// --- algo.RnullStr6.ch.AssignStrptr
12198// Copy from strptr (operator=)
12199inline void algo::RnullStr6::operator =(const algo::strptr &str) {
12200    ch_SetStrptr(*this, str);
12201}
12202
12203// --- algo.RnullStr6.ch.Set
12204// Copy from same type
12205// Copy value from RHS.
12206inline void algo::RnullStr6::operator =(const algo::RnullStr6& parent) {
12207    memcpy(ch, parent.ch, 6);
12208}
12209
12210// --- algo.RnullStr6.ch.Ctor
12211inline  algo::RnullStr6::RnullStr6(const algo::RnullStr6 &rhs) {
12212    operator =(rhs);
12213}
12214
12215// --- algo.RnullStr6.ch.CtorStrptr
12216inline  algo::RnullStr6::RnullStr6(const algo::strptr &rhs) {
12217    ch_SetStrptr(*this, rhs);
12218}
12219
12220// --- algo.RnullStr6.ch.Cast
12221inline algo::RnullStr6::operator algo::strptr () const {
12222    return ch_Getary(*this);
12223}
12224
12225// --- algo.RnullStr6..Lt
12226inline bool algo::RnullStr6_Lt(algo::RnullStr6 lhs, algo::RnullStr6 rhs) {
12227    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12228}
12229
12230// --- algo.RnullStr6..Cmp
12231inline i32 algo::RnullStr6_Cmp(algo::RnullStr6 lhs, algo::RnullStr6 rhs) {
12232    i32 retval = 0;
12233    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12234    return retval;
12235}
12236
12237// --- algo.RnullStr6..Init
12238// Set all fields to initial values.
12239inline void algo::RnullStr6_Init(algo::RnullStr6& parent) {
12240    memset(parent.ch, 0, 6);
12241}
12242
12243// --- algo.RnullStr6..Eq
12244inline bool algo::RnullStr6_Eq(algo::RnullStr6 lhs, algo::RnullStr6 rhs) {
12245    bool retval = true;
12246    retval = retval
12247    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
12248    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
12249    return retval;
12250}
12251
12252// --- algo.RnullStr6..Update
12253// Set value. Return true if new value is different from old value.
12254inline bool algo::RnullStr6_Update(algo::RnullStr6 &lhs, algo::RnullStr6 rhs) {
12255    bool ret = !RnullStr6_Eq(lhs, rhs); // compare values
12256    if (ret) {
12257        lhs = rhs; // update
12258    }
12259    return ret;
12260}
12261
12262// --- algo.RnullStr6..EqStrptr
12263inline bool algo::RnullStr6_EqStrptr(algo::RnullStr6 lhs, const algo::strptr& rhs) {
12264    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12265}
12266
12267inline bool algo::RnullStr60::operator ==(const algo::RnullStr60 &rhs) const {
12268    return algo::RnullStr60_Eq(const_cast<algo::RnullStr60&>(*this),const_cast<algo::RnullStr60&>(rhs));
12269}
12270
12271inline bool algo::RnullStr60::operator !=(const algo::RnullStr60 &rhs) const {
12272    return !algo::RnullStr60_Eq(const_cast<algo::RnullStr60&>(*this),const_cast<algo::RnullStr60&>(rhs));
12273}
12274
12275inline bool algo::RnullStr60::operator ==(const algo::strptr &rhs) const {
12276    return algo::RnullStr60_EqStrptr(const_cast<algo::RnullStr60&>(*this),rhs);
12277}
12278
12279inline bool algo::RnullStr60::operator <(const algo::RnullStr60 &rhs) const {
12280    return algo::RnullStr60_Lt(const_cast<algo::RnullStr60&>(*this),const_cast<algo::RnullStr60&>(rhs));
12281}
12282
12283inline bool algo::RnullStr60::operator >(const algo::RnullStr60 &rhs) const {
12284    return rhs < *this;
12285}
12286
12287inline bool algo::RnullStr60::operator <=(const algo::RnullStr60 &rhs) const {
12288    return !(rhs < *this);
12289}
12290
12291inline bool algo::RnullStr60::operator >=(const algo::RnullStr60 &rhs) const {
12292    return !(*this < rhs);
12293}
12294inline algo::RnullStr60::RnullStr60() {
12295    algo::RnullStr60_Init(*this);
12296}
12297
12298
12299// --- algo.RnullStr60.ch.Getary
12300// Access string as array of chars
12301inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr60& parent) {
12302    int len = ch_N(parent);
12303    algo::aryptr<char> ret((char*)parent.ch, len);
12304    return ret;
12305}
12306
12307// --- algo.RnullStr60.ch.HashStrptr
12308inline u32 algo::RnullStr60_Hash(u32 prev, const algo::strptr &str) {
12309    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12310}
12311
12312// --- algo.RnullStr60.ch.Init
12313inline void algo::ch_Init(algo::RnullStr60 &parent) {
12314    memset(parent.ch, 0, 60);
12315}
12316
12317// --- algo.RnullStr60.ch.Max
12318// always return constant 60
12319inline int algo::ch_Max(algo::RnullStr60& parent) {
12320    (void)parent;
12321    return 60;
12322}
12323
12324// --- algo.RnullStr60.ch.N
12325inline int algo::ch_N(const algo::RnullStr60& parent) {
12326    u64 ret;
12327    ret = 60;
12328    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12329        ret--;
12330    }
12331    return int(ret);
12332}
12333
12334// --- algo.RnullStr60.ch.AssignStrptr
12335// Copy from strptr (operator=)
12336inline void algo::RnullStr60::operator =(const algo::strptr &str) {
12337    ch_SetStrptr(*this, str);
12338}
12339
12340// --- algo.RnullStr60.ch.Set
12341// Copy from same type
12342// Copy value from RHS.
12343inline void algo::RnullStr60::operator =(const algo::RnullStr60& parent) {
12344    memcpy(ch, parent.ch, 60);
12345}
12346
12347// --- algo.RnullStr60.ch.Ctor
12348inline  algo::RnullStr60::RnullStr60(const algo::RnullStr60 &rhs) {
12349    operator =(rhs);
12350}
12351
12352// --- algo.RnullStr60.ch.CtorStrptr
12353inline  algo::RnullStr60::RnullStr60(const algo::strptr &rhs) {
12354    ch_SetStrptr(*this, rhs);
12355}
12356
12357// --- algo.RnullStr60.ch.Cast
12358inline algo::RnullStr60::operator algo::strptr () const {
12359    return ch_Getary(*this);
12360}
12361
12362// --- algo.RnullStr60..Lt
12363inline bool algo::RnullStr60_Lt(algo::RnullStr60& lhs, algo::RnullStr60& rhs) {
12364    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12365}
12366
12367// --- algo.RnullStr60..Cmp
12368inline i32 algo::RnullStr60_Cmp(algo::RnullStr60& lhs, algo::RnullStr60& rhs) {
12369    i32 retval = 0;
12370    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12371    return retval;
12372}
12373
12374// --- algo.RnullStr60..Init
12375// Set all fields to initial values.
12376inline void algo::RnullStr60_Init(algo::RnullStr60& parent) {
12377    memset(parent.ch, 0, 60);
12378}
12379
12380// --- algo.RnullStr60..Eq
12381inline bool algo::RnullStr60_Eq(algo::RnullStr60& lhs, algo::RnullStr60& rhs) {
12382    bool retval = true;
12383    retval = retval
12384    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12385    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12386    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12387    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12388    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12389    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12390    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
12391    &&*(u32*)(lhs.ch+56) == *(u32*)(rhs.ch+56);
12392    return retval;
12393}
12394
12395// --- algo.RnullStr60..Update
12396// Set value. Return true if new value is different from old value.
12397inline bool algo::RnullStr60_Update(algo::RnullStr60 &lhs, algo::RnullStr60& rhs) {
12398    bool ret = !RnullStr60_Eq(lhs, rhs); // compare values
12399    if (ret) {
12400        lhs = rhs; // update
12401    }
12402    return ret;
12403}
12404
12405// --- algo.RnullStr60..EqStrptr
12406inline bool algo::RnullStr60_EqStrptr(const algo::RnullStr60& lhs, const algo::strptr& rhs) {
12407    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12408}
12409
12410inline bool algo::RnullStr62::operator ==(const algo::RnullStr62 &rhs) const {
12411    return algo::RnullStr62_Eq(const_cast<algo::RnullStr62&>(*this),const_cast<algo::RnullStr62&>(rhs));
12412}
12413
12414inline bool algo::RnullStr62::operator !=(const algo::RnullStr62 &rhs) const {
12415    return !algo::RnullStr62_Eq(const_cast<algo::RnullStr62&>(*this),const_cast<algo::RnullStr62&>(rhs));
12416}
12417
12418inline bool algo::RnullStr62::operator ==(const algo::strptr &rhs) const {
12419    return algo::RnullStr62_EqStrptr(const_cast<algo::RnullStr62&>(*this),rhs);
12420}
12421
12422inline bool algo::RnullStr62::operator <(const algo::RnullStr62 &rhs) const {
12423    return algo::RnullStr62_Lt(const_cast<algo::RnullStr62&>(*this),const_cast<algo::RnullStr62&>(rhs));
12424}
12425
12426inline bool algo::RnullStr62::operator >(const algo::RnullStr62 &rhs) const {
12427    return rhs < *this;
12428}
12429
12430inline bool algo::RnullStr62::operator <=(const algo::RnullStr62 &rhs) const {
12431    return !(rhs < *this);
12432}
12433
12434inline bool algo::RnullStr62::operator >=(const algo::RnullStr62 &rhs) const {
12435    return !(*this < rhs);
12436}
12437inline algo::RnullStr62::RnullStr62() {
12438    algo::RnullStr62_Init(*this);
12439}
12440
12441
12442// --- algo.RnullStr62.ch.Getary
12443// Access string as array of chars
12444inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr62& parent) {
12445    int len = ch_N(parent);
12446    algo::aryptr<char> ret((char*)parent.ch, len);
12447    return ret;
12448}
12449
12450// --- algo.RnullStr62.ch.HashStrptr
12451inline u32 algo::RnullStr62_Hash(u32 prev, const algo::strptr &str) {
12452    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12453}
12454
12455// --- algo.RnullStr62.ch.Init
12456inline void algo::ch_Init(algo::RnullStr62 &parent) {
12457    memset(parent.ch, 0, 62);
12458}
12459
12460// --- algo.RnullStr62.ch.Max
12461// always return constant 62
12462inline int algo::ch_Max(algo::RnullStr62& parent) {
12463    (void)parent;
12464    return 62;
12465}
12466
12467// --- algo.RnullStr62.ch.N
12468inline int algo::ch_N(const algo::RnullStr62& parent) {
12469    u64 ret;
12470    ret = 62;
12471    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12472        ret--;
12473    }
12474    return int(ret);
12475}
12476
12477// --- algo.RnullStr62.ch.AssignStrptr
12478// Copy from strptr (operator=)
12479inline void algo::RnullStr62::operator =(const algo::strptr &str) {
12480    ch_SetStrptr(*this, str);
12481}
12482
12483// --- algo.RnullStr62.ch.Set
12484// Copy from same type
12485// Copy value from RHS.
12486inline void algo::RnullStr62::operator =(const algo::RnullStr62& parent) {
12487    memcpy(ch, parent.ch, 62);
12488}
12489
12490// --- algo.RnullStr62.ch.Ctor
12491inline  algo::RnullStr62::RnullStr62(const algo::RnullStr62 &rhs) {
12492    operator =(rhs);
12493}
12494
12495// --- algo.RnullStr62.ch.CtorStrptr
12496inline  algo::RnullStr62::RnullStr62(const algo::strptr &rhs) {
12497    ch_SetStrptr(*this, rhs);
12498}
12499
12500// --- algo.RnullStr62.ch.Cast
12501inline algo::RnullStr62::operator algo::strptr () const {
12502    return ch_Getary(*this);
12503}
12504
12505// --- algo.RnullStr62..Lt
12506inline bool algo::RnullStr62_Lt(algo::RnullStr62& lhs, algo::RnullStr62& rhs) {
12507    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12508}
12509
12510// --- algo.RnullStr62..Cmp
12511inline i32 algo::RnullStr62_Cmp(algo::RnullStr62& lhs, algo::RnullStr62& rhs) {
12512    i32 retval = 0;
12513    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12514    return retval;
12515}
12516
12517// --- algo.RnullStr62..Init
12518// Set all fields to initial values.
12519inline void algo::RnullStr62_Init(algo::RnullStr62& parent) {
12520    memset(parent.ch, 0, 62);
12521}
12522
12523// --- algo.RnullStr62..Eq
12524inline bool algo::RnullStr62_Eq(algo::RnullStr62& lhs, algo::RnullStr62& rhs) {
12525    bool retval = true;
12526    retval = retval
12527    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12528    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12529    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12530    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12531    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12532    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12533    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
12534    &&*(u32*)(lhs.ch+56) == *(u32*)(rhs.ch+56)
12535    &&*(u16*)(lhs.ch+60) == *(u16*)(rhs.ch+60);
12536    return retval;
12537}
12538
12539// --- algo.RnullStr62..Update
12540// Set value. Return true if new value is different from old value.
12541inline bool algo::RnullStr62_Update(algo::RnullStr62 &lhs, algo::RnullStr62& rhs) {
12542    bool ret = !RnullStr62_Eq(lhs, rhs); // compare values
12543    if (ret) {
12544        lhs = rhs; // update
12545    }
12546    return ret;
12547}
12548
12549// --- algo.RnullStr62..EqStrptr
12550inline bool algo::RnullStr62_EqStrptr(const algo::RnullStr62& lhs, const algo::strptr& rhs) {
12551    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12552}
12553inline algo::RnullStr66::RnullStr66() {
12554    algo::RnullStr66_Init(*this);
12555}
12556
12557
12558// --- algo.RnullStr66.ch.Getary
12559// Access string as array of chars
12560inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr66& parent) {
12561    int len = ch_N(parent);
12562    algo::aryptr<char> ret((char*)parent.ch, len);
12563    return ret;
12564}
12565
12566// --- algo.RnullStr66.ch.HashStrptr
12567inline u32 algo::RnullStr66_Hash(u32 prev, const algo::strptr &str) {
12568    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12569}
12570
12571// --- algo.RnullStr66.ch.Init
12572inline void algo::ch_Init(algo::RnullStr66 &parent) {
12573    memset(parent.ch, 0, 66);
12574}
12575
12576// --- algo.RnullStr66.ch.Max
12577// always return constant 66
12578inline int algo::ch_Max(algo::RnullStr66& parent) {
12579    (void)parent;
12580    return 66;
12581}
12582
12583// --- algo.RnullStr66.ch.N
12584inline int algo::ch_N(const algo::RnullStr66& parent) {
12585    u64 ret;
12586    ret = 66;
12587    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12588        ret--;
12589    }
12590    return int(ret);
12591}
12592
12593// --- algo.RnullStr66.ch.AssignStrptr
12594// Copy from strptr (operator=)
12595inline void algo::RnullStr66::operator =(const algo::strptr &str) {
12596    ch_SetStrptr(*this, str);
12597}
12598
12599// --- algo.RnullStr66.ch.Set
12600// Copy from same type
12601// Copy value from RHS.
12602inline void algo::RnullStr66::operator =(const algo::RnullStr66& parent) {
12603    memcpy(ch, parent.ch, 66);
12604}
12605
12606// --- algo.RnullStr66.ch.Ctor
12607inline  algo::RnullStr66::RnullStr66(const algo::RnullStr66 &rhs) {
12608    operator =(rhs);
12609}
12610
12611// --- algo.RnullStr66.ch.CtorStrptr
12612inline  algo::RnullStr66::RnullStr66(const algo::strptr &rhs) {
12613    ch_SetStrptr(*this, rhs);
12614}
12615
12616// --- algo.RnullStr66.ch.Cast
12617inline algo::RnullStr66::operator algo::strptr () const {
12618    return ch_Getary(*this);
12619}
12620
12621// --- algo.RnullStr66..Lt
12622inline bool algo::RnullStr66_Lt(algo::RnullStr66& lhs, algo::RnullStr66& rhs) {
12623    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12624}
12625
12626// --- algo.RnullStr66..Cmp
12627inline i32 algo::RnullStr66_Cmp(algo::RnullStr66& lhs, algo::RnullStr66& rhs) {
12628    i32 retval = 0;
12629    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12630    return retval;
12631}
12632
12633// --- algo.RnullStr66..Init
12634// Set all fields to initial values.
12635inline void algo::RnullStr66_Init(algo::RnullStr66& parent) {
12636    memset(parent.ch, 0, 66);
12637}
12638
12639// --- algo.RnullStr66..Eq
12640inline bool algo::RnullStr66_Eq(algo::RnullStr66& lhs, algo::RnullStr66& rhs) {
12641    bool retval = true;
12642    retval = retval
12643    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12644    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12645    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12646    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12647    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12648    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12649    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
12650    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
12651    &&*(u16*)(lhs.ch+64) == *(u16*)(rhs.ch+64);
12652    return retval;
12653}
12654
12655// --- algo.RnullStr66..Update
12656// Set value. Return true if new value is different from old value.
12657inline bool algo::RnullStr66_Update(algo::RnullStr66 &lhs, algo::RnullStr66& rhs) {
12658    bool ret = !RnullStr66_Eq(lhs, rhs); // compare values
12659    if (ret) {
12660        lhs = rhs; // update
12661    }
12662    return ret;
12663}
12664
12665// --- algo.RnullStr66..EqStrptr
12666inline bool algo::RnullStr66_EqStrptr(const algo::RnullStr66& lhs, const algo::strptr& rhs) {
12667    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12668}
12669
12670inline bool algo::RnullStr6_U32::operator ==(const algo::RnullStr6_U32 &rhs) const {
12671    return algo::RnullStr6_U32_Eq(const_cast<algo::RnullStr6_U32&>(*this),const_cast<algo::RnullStr6_U32&>(rhs));
12672}
12673
12674inline bool algo::RnullStr6_U32::operator !=(const algo::RnullStr6_U32 &rhs) const {
12675    return !algo::RnullStr6_U32_Eq(const_cast<algo::RnullStr6_U32&>(*this),const_cast<algo::RnullStr6_U32&>(rhs));
12676}
12677
12678inline bool algo::RnullStr6_U32::operator ==(const algo::strptr &rhs) const {
12679    return algo::RnullStr6_U32_EqStrptr(const_cast<algo::RnullStr6_U32&>(*this),rhs);
12680}
12681inline algo::RnullStr6_U32::RnullStr6_U32() {
12682    algo::RnullStr6_U32_Init(*this);
12683}
12684
12685
12686// --- algo.RnullStr6_U32.ch.Getary
12687// Access string as array of chars
12688inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr6_U32& parent) {
12689    int len = ch_N(parent);
12690    algo::aryptr<char> ret((char*)parent.ch, len);
12691    return ret;
12692}
12693
12694// --- algo.RnullStr6_U32.ch.HashStrptr
12695inline u32 algo::RnullStr6_U32_Hash(u32 prev, const algo::strptr &str) {
12696    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12697}
12698
12699// --- algo.RnullStr6_U32.ch.Init
12700inline void algo::ch_Init(algo::RnullStr6_U32 &parent) {
12701    memset(parent.ch, 0, 6);
12702}
12703
12704// --- algo.RnullStr6_U32.ch.Max
12705// always return constant 6
12706inline int algo::ch_Max(algo::RnullStr6_U32& parent) {
12707    (void)parent;
12708    return 6;
12709}
12710
12711// --- algo.RnullStr6_U32.ch.N
12712inline int algo::ch_N(const algo::RnullStr6_U32& parent) {
12713    u64 ret;
12714    ret = 6;
12715    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12716        ret--;
12717    }
12718    return int(ret);
12719}
12720
12721// --- algo.RnullStr6_U32.ch.AssignStrptr
12722// Copy from strptr (operator=)
12723inline void algo::RnullStr6_U32::operator =(const algo::strptr &str) {
12724    ch_SetStrptr(*this, str);
12725}
12726
12727// --- algo.RnullStr6_U32.ch.Set
12728// Copy from same type
12729// Copy value from RHS.
12730inline void algo::RnullStr6_U32::operator =(const algo::RnullStr6_U32& parent) {
12731    memcpy(ch, parent.ch, 6);
12732}
12733
12734// --- algo.RnullStr6_U32.ch.Ctor
12735inline  algo::RnullStr6_U32::RnullStr6_U32(const algo::RnullStr6_U32 &rhs) {
12736    operator =(rhs);
12737}
12738
12739// --- algo.RnullStr6_U32.ch.CtorStrptr
12740inline  algo::RnullStr6_U32::RnullStr6_U32(const algo::strptr &rhs) {
12741    ch_SetStrptr(*this, rhs);
12742}
12743
12744// --- algo.RnullStr6_U32.ch.Cast
12745inline algo::RnullStr6_U32::operator algo::strptr () const {
12746    return ch_Getary(*this);
12747}
12748
12749// --- algo.RnullStr6_U32..Cmp
12750inline i32 algo::RnullStr6_U32_Cmp(algo::RnullStr6_U32& lhs, algo::RnullStr6_U32& rhs) {
12751    i32 retval = 0;
12752    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12753    return retval;
12754}
12755
12756// --- algo.RnullStr6_U32..Init
12757// Set all fields to initial values.
12758inline void algo::RnullStr6_U32_Init(algo::RnullStr6_U32& parent) {
12759    memset(parent.ch, 0, 6);
12760}
12761
12762// --- algo.RnullStr6_U32..Eq
12763inline bool algo::RnullStr6_U32_Eq(algo::RnullStr6_U32& lhs, algo::RnullStr6_U32& rhs) {
12764    bool retval = true;
12765    retval = retval
12766    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
12767    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
12768    return retval;
12769}
12770
12771// --- algo.RnullStr6_U32..EqStrptr
12772inline bool algo::RnullStr6_U32_EqStrptr(const algo::RnullStr6_U32& lhs, const algo::strptr& rhs) {
12773    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12774}
12775
12776inline bool algo::RnullStr7::operator ==(const algo::RnullStr7 &rhs) const {
12777    return algo::RnullStr7_Eq(const_cast<algo::RnullStr7&>(*this),const_cast<algo::RnullStr7&>(rhs));
12778}
12779
12780inline bool algo::RnullStr7::operator !=(const algo::RnullStr7 &rhs) const {
12781    return !algo::RnullStr7_Eq(const_cast<algo::RnullStr7&>(*this),const_cast<algo::RnullStr7&>(rhs));
12782}
12783
12784inline bool algo::RnullStr7::operator ==(const algo::strptr &rhs) const {
12785    return algo::RnullStr7_EqStrptr(const_cast<algo::RnullStr7&>(*this),rhs);
12786}
12787
12788inline bool algo::RnullStr7::operator <(const algo::RnullStr7 &rhs) const {
12789    return algo::RnullStr7_Lt(const_cast<algo::RnullStr7&>(*this),const_cast<algo::RnullStr7&>(rhs));
12790}
12791
12792inline bool algo::RnullStr7::operator >(const algo::RnullStr7 &rhs) const {
12793    return rhs < *this;
12794}
12795
12796inline bool algo::RnullStr7::operator <=(const algo::RnullStr7 &rhs) const {
12797    return !(rhs < *this);
12798}
12799
12800inline bool algo::RnullStr7::operator >=(const algo::RnullStr7 &rhs) const {
12801    return !(*this < rhs);
12802}
12803inline algo::RnullStr7::RnullStr7() {
12804    algo::RnullStr7_Init(*this);
12805}
12806
12807
12808// --- algo.RnullStr7.ch.Getary
12809// Access string as array of chars
12810inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr7& parent) {
12811    int len = ch_N(parent);
12812    algo::aryptr<char> ret((char*)parent.ch, len);
12813    return ret;
12814}
12815
12816// --- algo.RnullStr7.ch.HashStrptr
12817inline u32 algo::RnullStr7_Hash(u32 prev, const algo::strptr &str) {
12818    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12819}
12820
12821// --- algo.RnullStr7.ch.Init
12822inline void algo::ch_Init(algo::RnullStr7 &parent) {
12823    memset(parent.ch, 0, 7);
12824}
12825
12826// --- algo.RnullStr7.ch.Max
12827// always return constant 7
12828inline int algo::ch_Max(algo::RnullStr7& parent) {
12829    (void)parent;
12830    return 7;
12831}
12832
12833// --- algo.RnullStr7.ch.N
12834inline int algo::ch_N(const algo::RnullStr7& parent) {
12835    u64 ret;
12836    ret = 7;
12837    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12838        ret--;
12839    }
12840    return int(ret);
12841}
12842
12843// --- algo.RnullStr7.ch.AssignStrptr
12844// Copy from strptr (operator=)
12845inline void algo::RnullStr7::operator =(const algo::strptr &str) {
12846    ch_SetStrptr(*this, str);
12847}
12848
12849// --- algo.RnullStr7.ch.Set
12850// Copy from same type
12851// Copy value from RHS.
12852inline void algo::RnullStr7::operator =(const algo::RnullStr7& parent) {
12853    memcpy(ch, parent.ch, 7);
12854}
12855
12856// --- algo.RnullStr7.ch.Ctor
12857inline  algo::RnullStr7::RnullStr7(const algo::RnullStr7 &rhs) {
12858    operator =(rhs);
12859}
12860
12861// --- algo.RnullStr7.ch.CtorStrptr
12862inline  algo::RnullStr7::RnullStr7(const algo::strptr &rhs) {
12863    ch_SetStrptr(*this, rhs);
12864}
12865
12866// --- algo.RnullStr7.ch.Cast
12867inline algo::RnullStr7::operator algo::strptr () const {
12868    return ch_Getary(*this);
12869}
12870
12871// --- algo.RnullStr7..Lt
12872inline bool algo::RnullStr7_Lt(algo::RnullStr7 lhs, algo::RnullStr7 rhs) {
12873    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12874}
12875
12876// --- algo.RnullStr7..Cmp
12877inline i32 algo::RnullStr7_Cmp(algo::RnullStr7 lhs, algo::RnullStr7 rhs) {
12878    i32 retval = 0;
12879    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12880    return retval;
12881}
12882
12883// --- algo.RnullStr7..Init
12884// Set all fields to initial values.
12885inline void algo::RnullStr7_Init(algo::RnullStr7& parent) {
12886    memset(parent.ch, 0, 7);
12887}
12888
12889// --- algo.RnullStr7..Eq
12890inline bool algo::RnullStr7_Eq(algo::RnullStr7 lhs, algo::RnullStr7 rhs) {
12891    bool retval = true;
12892    retval = retval
12893    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
12894    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
12895    &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
12896    return retval;
12897}
12898
12899// --- algo.RnullStr7..Update
12900// Set value. Return true if new value is different from old value.
12901inline bool algo::RnullStr7_Update(algo::RnullStr7 &lhs, algo::RnullStr7 rhs) {
12902    bool ret = !RnullStr7_Eq(lhs, rhs); // compare values
12903    if (ret) {
12904        lhs = rhs; // update
12905    }
12906    return ret;
12907}
12908
12909// --- algo.RnullStr7..EqStrptr
12910inline bool algo::RnullStr7_EqStrptr(algo::RnullStr7 lhs, const algo::strptr& rhs) {
12911    return algo::strptr_Eq(ch_Getary(lhs), rhs);
12912}
12913inline algo::RnullStr8::RnullStr8() {
12914    algo::RnullStr8_Init(*this);
12915}
12916
12917
12918// --- algo.RnullStr8.ch.Getary
12919// Access string as array of chars
12920inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr8& parent) {
12921    int len = ch_N(parent);
12922    algo::aryptr<char> ret((char*)parent.ch, len);
12923    return ret;
12924}
12925
12926// --- algo.RnullStr8.ch.HashStrptr
12927inline u32 algo::RnullStr8_Hash(u32 prev, const algo::strptr &str) {
12928    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12929}
12930
12931// --- algo.RnullStr8.ch.Init
12932inline void algo::ch_Init(algo::RnullStr8 &parent) {
12933    memset(parent.ch, 0, 8);
12934}
12935
12936// --- algo.RnullStr8.ch.Max
12937// always return constant 8
12938inline int algo::ch_Max(algo::RnullStr8& parent) {
12939    (void)parent;
12940    return 8;
12941}
12942
12943// --- algo.RnullStr8.ch.N
12944inline int algo::ch_N(const algo::RnullStr8& parent) {
12945    u64 ret;
12946    ret = 8;
12947    while (ret>0 && parent.ch[ret-1]==u8(0)) {
12948        ret--;
12949    }
12950    return int(ret);
12951}
12952
12953// --- algo.RnullStr8.ch.AssignStrptr
12954// Copy from strptr (operator=)
12955inline void algo::RnullStr8::operator =(const algo::strptr &str) {
12956    ch_SetStrptr(*this, str);
12957}
12958
12959// --- algo.RnullStr8.ch.Set
12960// Copy from same type
12961// Copy value from RHS.
12962inline void algo::RnullStr8::operator =(const algo::RnullStr8& parent) {
12963    memcpy(ch, parent.ch, 8);
12964}
12965
12966// --- algo.RnullStr8.ch.Ctor
12967inline  algo::RnullStr8::RnullStr8(const algo::RnullStr8 &rhs) {
12968    operator =(rhs);
12969}
12970
12971// --- algo.RnullStr8.ch.CtorStrptr
12972inline  algo::RnullStr8::RnullStr8(const algo::strptr &rhs) {
12973    ch_SetStrptr(*this, rhs);
12974}
12975
12976// --- algo.RnullStr8.ch.Cast
12977inline algo::RnullStr8::operator algo::strptr () const {
12978    return ch_Getary(*this);
12979}
12980
12981// --- algo.RnullStr8..Lt
12982inline bool algo::RnullStr8_Lt(algo::RnullStr8 lhs, algo::RnullStr8 rhs) {
12983    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12984}
12985
12986// --- algo.RnullStr8..Cmp
12987inline i32 algo::RnullStr8_Cmp(algo::RnullStr8 lhs, algo::RnullStr8 rhs) {
12988    i32 retval = 0;
12989    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12990    return retval;
12991}
12992
12993// --- algo.RnullStr8..Init
12994// Set all fields to initial values.
12995inline void algo::RnullStr8_Init(algo::RnullStr8& parent) {
12996    memset(parent.ch, 0, 8);
12997}
12998
12999// --- algo.RnullStr8..Eq
13000inline bool algo::RnullStr8_Eq(algo::RnullStr8 lhs, algo::RnullStr8 rhs) {
13001    bool retval = true;
13002    retval = retval
13003    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
13004    return retval;
13005}
13006
13007// --- algo.RnullStr8..Update
13008// Set value. Return true if new value is different from old value.
13009inline bool algo::RnullStr8_Update(algo::RnullStr8 &lhs, algo::RnullStr8 rhs) {
13010    bool ret = !RnullStr8_Eq(lhs, rhs); // compare values
13011    if (ret) {
13012        lhs = rhs; // update
13013    }
13014    return ret;
13015}
13016
13017// --- algo.RnullStr8..EqStrptr
13018inline bool algo::RnullStr8_EqStrptr(algo::RnullStr8 lhs, const algo::strptr& rhs) {
13019    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13020}
13021inline algo::RnullStr80::RnullStr80() {
13022    algo::RnullStr80_Init(*this);
13023}
13024
13025
13026// --- algo.RnullStr80.ch.Getary
13027// Access string as array of chars
13028inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr80& parent) {
13029    int len = ch_N(parent);
13030    algo::aryptr<char> ret((char*)parent.ch, len);
13031    return ret;
13032}
13033
13034// --- algo.RnullStr80.ch.HashStrptr
13035inline u32 algo::RnullStr80_Hash(u32 prev, const algo::strptr &str) {
13036    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13037}
13038
13039// --- algo.RnullStr80.ch.Init
13040inline void algo::ch_Init(algo::RnullStr80 &parent) {
13041    memset(parent.ch, 0, 80);
13042}
13043
13044// --- algo.RnullStr80.ch.Max
13045// always return constant 80
13046inline int algo::ch_Max(algo::RnullStr80& parent) {
13047    (void)parent;
13048    return 80;
13049}
13050
13051// --- algo.RnullStr80.ch.N
13052inline int algo::ch_N(const algo::RnullStr80& parent) {
13053    u64 ret;
13054    ret = 80;
13055    while (ret>0 && parent.ch[ret-1]==u8(0)) {
13056        ret--;
13057    }
13058    return int(ret);
13059}
13060
13061// --- algo.RnullStr80.ch.AssignStrptr
13062// Copy from strptr (operator=)
13063inline void algo::RnullStr80::operator =(const algo::strptr &str) {
13064    ch_SetStrptr(*this, str);
13065}
13066
13067// --- algo.RnullStr80.ch.Set
13068// Copy from same type
13069// Copy value from RHS.
13070inline void algo::RnullStr80::operator =(const algo::RnullStr80& parent) {
13071    memcpy(ch, parent.ch, 80);
13072}
13073
13074// --- algo.RnullStr80.ch.Ctor
13075inline  algo::RnullStr80::RnullStr80(const algo::RnullStr80 &rhs) {
13076    operator =(rhs);
13077}
13078
13079// --- algo.RnullStr80.ch.CtorStrptr
13080inline  algo::RnullStr80::RnullStr80(const algo::strptr &rhs) {
13081    ch_SetStrptr(*this, rhs);
13082}
13083
13084// --- algo.RnullStr80.ch.Cast
13085inline algo::RnullStr80::operator algo::strptr () const {
13086    return ch_Getary(*this);
13087}
13088
13089// --- algo.RnullStr80..Lt
13090inline bool algo::RnullStr80_Lt(algo::RnullStr80& lhs, algo::RnullStr80& rhs) {
13091    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
13092}
13093
13094// --- algo.RnullStr80..Cmp
13095inline i32 algo::RnullStr80_Cmp(algo::RnullStr80& lhs, algo::RnullStr80& rhs) {
13096    i32 retval = 0;
13097    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13098    return retval;
13099}
13100
13101// --- algo.RnullStr80..Init
13102// Set all fields to initial values.
13103inline void algo::RnullStr80_Init(algo::RnullStr80& parent) {
13104    memset(parent.ch, 0, 80);
13105}
13106
13107// --- algo.RnullStr80..Eq
13108inline bool algo::RnullStr80_Eq(algo::RnullStr80& lhs, algo::RnullStr80& rhs) {
13109    bool retval = true;
13110    retval = retval
13111    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13112    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
13113    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
13114    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
13115    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
13116    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
13117    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
13118    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
13119    &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
13120    &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72);
13121    return retval;
13122}
13123
13124// --- algo.RnullStr80..Update
13125// Set value. Return true if new value is different from old value.
13126inline bool algo::RnullStr80_Update(algo::RnullStr80 &lhs, algo::RnullStr80& rhs) {
13127    bool ret = !RnullStr80_Eq(lhs, rhs); // compare values
13128    if (ret) {
13129        lhs = rhs; // update
13130    }
13131    return ret;
13132}
13133
13134// --- algo.RnullStr80..EqStrptr
13135inline bool algo::RnullStr80_EqStrptr(const algo::RnullStr80& lhs, const algo::strptr& rhs) {
13136    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13137}
13138
13139inline bool algo::RnullStr9::operator ==(const algo::RnullStr9 &rhs) const {
13140    return algo::RnullStr9_Eq(const_cast<algo::RnullStr9&>(*this),const_cast<algo::RnullStr9&>(rhs));
13141}
13142
13143inline bool algo::RnullStr9::operator !=(const algo::RnullStr9 &rhs) const {
13144    return !algo::RnullStr9_Eq(const_cast<algo::RnullStr9&>(*this),const_cast<algo::RnullStr9&>(rhs));
13145}
13146
13147inline bool algo::RnullStr9::operator ==(const algo::strptr &rhs) const {
13148    return algo::RnullStr9_EqStrptr(const_cast<algo::RnullStr9&>(*this),rhs);
13149}
13150
13151inline bool algo::RnullStr9::operator <(const algo::RnullStr9 &rhs) const {
13152    return algo::RnullStr9_Lt(const_cast<algo::RnullStr9&>(*this),const_cast<algo::RnullStr9&>(rhs));
13153}
13154
13155inline bool algo::RnullStr9::operator >(const algo::RnullStr9 &rhs) const {
13156    return rhs < *this;
13157}
13158
13159inline bool algo::RnullStr9::operator <=(const algo::RnullStr9 &rhs) const {
13160    return !(rhs < *this);
13161}
13162
13163inline bool algo::RnullStr9::operator >=(const algo::RnullStr9 &rhs) const {
13164    return !(*this < rhs);
13165}
13166inline algo::RnullStr9::RnullStr9() {
13167    algo::RnullStr9_Init(*this);
13168}
13169
13170
13171// --- algo.RnullStr9.ch.Getary
13172// Access string as array of chars
13173inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr9& parent) {
13174    int len = ch_N(parent);
13175    algo::aryptr<char> ret((char*)parent.ch, len);
13176    return ret;
13177}
13178
13179// --- algo.RnullStr9.ch.HashStrptr
13180inline u32 algo::RnullStr9_Hash(u32 prev, const algo::strptr &str) {
13181    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13182}
13183
13184// --- algo.RnullStr9.ch.Init
13185inline void algo::ch_Init(algo::RnullStr9 &parent) {
13186    memset(parent.ch, 0, 9);
13187}
13188
13189// --- algo.RnullStr9.ch.Max
13190// always return constant 9
13191inline int algo::ch_Max(algo::RnullStr9& parent) {
13192    (void)parent;
13193    return 9;
13194}
13195
13196// --- algo.RnullStr9.ch.N
13197inline int algo::ch_N(const algo::RnullStr9& parent) {
13198    u64 ret;
13199    ret = 9;
13200    while (ret>0 && parent.ch[ret-1]==u8(0)) {
13201        ret--;
13202    }
13203    return int(ret);
13204}
13205
13206// --- algo.RnullStr9.ch.AssignStrptr
13207// Copy from strptr (operator=)
13208inline void algo::RnullStr9::operator =(const algo::strptr &str) {
13209    ch_SetStrptr(*this, str);
13210}
13211
13212// --- algo.RnullStr9.ch.Set
13213// Copy from same type
13214// Copy value from RHS.
13215inline void algo::RnullStr9::operator =(const algo::RnullStr9& parent) {
13216    memcpy(ch, parent.ch, 9);
13217}
13218
13219// --- algo.RnullStr9.ch.Ctor
13220inline  algo::RnullStr9::RnullStr9(const algo::RnullStr9 &rhs) {
13221    operator =(rhs);
13222}
13223
13224// --- algo.RnullStr9.ch.CtorStrptr
13225inline  algo::RnullStr9::RnullStr9(const algo::strptr &rhs) {
13226    ch_SetStrptr(*this, rhs);
13227}
13228
13229// --- algo.RnullStr9.ch.Cast
13230inline algo::RnullStr9::operator algo::strptr () const {
13231    return ch_Getary(*this);
13232}
13233
13234// --- algo.RnullStr9..Lt
13235inline bool algo::RnullStr9_Lt(algo::RnullStr9& lhs, algo::RnullStr9& rhs) {
13236    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
13237}
13238
13239// --- algo.RnullStr9..Cmp
13240inline i32 algo::RnullStr9_Cmp(algo::RnullStr9& lhs, algo::RnullStr9& rhs) {
13241    i32 retval = 0;
13242    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13243    return retval;
13244}
13245
13246// --- algo.RnullStr9..Init
13247// Set all fields to initial values.
13248inline void algo::RnullStr9_Init(algo::RnullStr9& parent) {
13249    memset(parent.ch, 0, 9);
13250}
13251
13252// --- algo.RnullStr9..Eq
13253inline bool algo::RnullStr9_Eq(algo::RnullStr9& lhs, algo::RnullStr9& rhs) {
13254    bool retval = true;
13255    retval = retval
13256    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13257    &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
13258    return retval;
13259}
13260
13261// --- algo.RnullStr9..Update
13262// Set value. Return true if new value is different from old value.
13263inline bool algo::RnullStr9_Update(algo::RnullStr9 &lhs, algo::RnullStr9& rhs) {
13264    bool ret = !RnullStr9_Eq(lhs, rhs); // compare values
13265    if (ret) {
13266        lhs = rhs; // update
13267    }
13268    return ret;
13269}
13270
13271// --- algo.RnullStr9..EqStrptr
13272inline bool algo::RnullStr9_EqStrptr(const algo::RnullStr9& lhs, const algo::strptr& rhs) {
13273    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13274}
13275
13276inline bool algo::RspaceStr10::operator ==(const algo::RspaceStr10 &rhs) const {
13277    return algo::RspaceStr10_Eq(const_cast<algo::RspaceStr10&>(*this),const_cast<algo::RspaceStr10&>(rhs));
13278}
13279
13280inline bool algo::RspaceStr10::operator !=(const algo::RspaceStr10 &rhs) const {
13281    return !algo::RspaceStr10_Eq(const_cast<algo::RspaceStr10&>(*this),const_cast<algo::RspaceStr10&>(rhs));
13282}
13283
13284inline bool algo::RspaceStr10::operator ==(const algo::strptr &rhs) const {
13285    return algo::RspaceStr10_EqStrptr(const_cast<algo::RspaceStr10&>(*this),rhs);
13286}
13287inline algo::RspaceStr10::RspaceStr10() {
13288    algo::RspaceStr10_Init(*this);
13289}
13290
13291
13292// --- algo.RspaceStr10.ch.Getary
13293// Access string as array of chars
13294inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr10& parent) {
13295    int len = ch_N(parent);
13296    algo::aryptr<char> ret((char*)parent.ch, len);
13297    return ret;
13298}
13299
13300// --- algo.RspaceStr10.ch.HashStrptr
13301inline u32 algo::RspaceStr10_Hash(u32 prev, const algo::strptr &str) {
13302    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13303}
13304
13305// --- algo.RspaceStr10.ch.Init
13306inline void algo::ch_Init(algo::RspaceStr10 &parent) {
13307    memset(parent.ch, ' ', 10);
13308}
13309
13310// --- algo.RspaceStr10.ch.Max
13311// always return constant 10
13312inline int algo::ch_Max(algo::RspaceStr10& parent) {
13313    (void)parent;
13314    return 10;
13315}
13316
13317// --- algo.RspaceStr10.ch.N
13318inline int algo::ch_N(const algo::RspaceStr10& parent) {
13319    u64 ret;
13320    ret = 10;
13321    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13322        ret--;
13323    }
13324    return int(ret);
13325}
13326
13327// --- algo.RspaceStr10.ch.AssignStrptr
13328// Copy from strptr (operator=)
13329inline void algo::RspaceStr10::operator =(const algo::strptr &str) {
13330    ch_SetStrptr(*this, str);
13331}
13332
13333// --- algo.RspaceStr10.ch.Set
13334// Copy from same type
13335// Copy value from RHS.
13336inline void algo::RspaceStr10::operator =(const algo::RspaceStr10& parent) {
13337    memcpy(ch, parent.ch, 10);
13338}
13339
13340// --- algo.RspaceStr10.ch.Ctor
13341inline  algo::RspaceStr10::RspaceStr10(const algo::RspaceStr10 &rhs) {
13342    operator =(rhs);
13343}
13344
13345// --- algo.RspaceStr10.ch.CtorStrptr
13346inline  algo::RspaceStr10::RspaceStr10(const algo::strptr &rhs) {
13347    ch_SetStrptr(*this, rhs);
13348}
13349
13350// --- algo.RspaceStr10.ch.Cast
13351inline algo::RspaceStr10::operator algo::strptr () const {
13352    return ch_Getary(*this);
13353}
13354
13355// --- algo.RspaceStr10..Cmp
13356inline i32 algo::RspaceStr10_Cmp(algo::RspaceStr10 lhs, algo::RspaceStr10 rhs) {
13357    i32 retval = 0;
13358    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13359    return retval;
13360}
13361
13362// --- algo.RspaceStr10..Init
13363// Set all fields to initial values.
13364inline void algo::RspaceStr10_Init(algo::RspaceStr10& parent) {
13365    memset(parent.ch, ' ', 10);
13366}
13367
13368// --- algo.RspaceStr10..Eq
13369inline bool algo::RspaceStr10_Eq(algo::RspaceStr10 lhs, algo::RspaceStr10 rhs) {
13370    bool retval = true;
13371    retval = retval
13372    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13373    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
13374    return retval;
13375}
13376
13377// --- algo.RspaceStr10..EqStrptr
13378inline bool algo::RspaceStr10_EqStrptr(algo::RspaceStr10 lhs, const algo::strptr& rhs) {
13379    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13380}
13381
13382inline bool algo::RspaceStr100::operator ==(const algo::RspaceStr100 &rhs) const {
13383    return algo::RspaceStr100_Eq(const_cast<algo::RspaceStr100&>(*this),const_cast<algo::RspaceStr100&>(rhs));
13384}
13385
13386inline bool algo::RspaceStr100::operator !=(const algo::RspaceStr100 &rhs) const {
13387    return !algo::RspaceStr100_Eq(const_cast<algo::RspaceStr100&>(*this),const_cast<algo::RspaceStr100&>(rhs));
13388}
13389
13390inline bool algo::RspaceStr100::operator ==(const algo::strptr &rhs) const {
13391    return algo::RspaceStr100_EqStrptr(const_cast<algo::RspaceStr100&>(*this),rhs);
13392}
13393inline algo::RspaceStr100::RspaceStr100() {
13394    algo::RspaceStr100_Init(*this);
13395}
13396
13397
13398// --- algo.RspaceStr100.ch.Getary
13399// Access string as array of chars
13400inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr100& parent) {
13401    int len = ch_N(parent);
13402    algo::aryptr<char> ret((char*)parent.ch, len);
13403    return ret;
13404}
13405
13406// --- algo.RspaceStr100.ch.HashStrptr
13407inline u32 algo::RspaceStr100_Hash(u32 prev, const algo::strptr &str) {
13408    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13409}
13410
13411// --- algo.RspaceStr100.ch.Init
13412inline void algo::ch_Init(algo::RspaceStr100 &parent) {
13413    memset(parent.ch, ' ', 100);
13414}
13415
13416// --- algo.RspaceStr100.ch.Max
13417// always return constant 100
13418inline int algo::ch_Max(algo::RspaceStr100& parent) {
13419    (void)parent;
13420    return 100;
13421}
13422
13423// --- algo.RspaceStr100.ch.N
13424inline int algo::ch_N(const algo::RspaceStr100& parent) {
13425    u64 ret;
13426    ret = 100;
13427    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13428        ret--;
13429    }
13430    return int(ret);
13431}
13432
13433// --- algo.RspaceStr100.ch.AssignStrptr
13434// Copy from strptr (operator=)
13435inline void algo::RspaceStr100::operator =(const algo::strptr &str) {
13436    ch_SetStrptr(*this, str);
13437}
13438
13439// --- algo.RspaceStr100.ch.Set
13440// Copy from same type
13441// Copy value from RHS.
13442inline void algo::RspaceStr100::operator =(const algo::RspaceStr100& parent) {
13443    memcpy(ch, parent.ch, 100);
13444}
13445
13446// --- algo.RspaceStr100.ch.Ctor
13447inline  algo::RspaceStr100::RspaceStr100(const algo::RspaceStr100 &rhs) {
13448    operator =(rhs);
13449}
13450
13451// --- algo.RspaceStr100.ch.CtorStrptr
13452inline  algo::RspaceStr100::RspaceStr100(const algo::strptr &rhs) {
13453    ch_SetStrptr(*this, rhs);
13454}
13455
13456// --- algo.RspaceStr100.ch.Cast
13457inline algo::RspaceStr100::operator algo::strptr () const {
13458    return ch_Getary(*this);
13459}
13460
13461// --- algo.RspaceStr100..Cmp
13462inline i32 algo::RspaceStr100_Cmp(algo::RspaceStr100& lhs, algo::RspaceStr100& rhs) {
13463    i32 retval = 0;
13464    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13465    return retval;
13466}
13467
13468// --- algo.RspaceStr100..Init
13469// Set all fields to initial values.
13470inline void algo::RspaceStr100_Init(algo::RspaceStr100& parent) {
13471    memset(parent.ch, ' ', 100);
13472}
13473
13474// --- algo.RspaceStr100..Eq
13475inline bool algo::RspaceStr100_Eq(algo::RspaceStr100& lhs, algo::RspaceStr100& rhs) {
13476    bool retval = true;
13477    retval = retval
13478    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13479    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
13480    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
13481    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
13482    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
13483    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
13484    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
13485    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
13486    &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
13487    &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72)
13488    &&*(u64*)(lhs.ch+80) == *(u64*)(rhs.ch+80)
13489    &&*(u64*)(lhs.ch+88) == *(u64*)(rhs.ch+88)
13490    &&*(u32*)(lhs.ch+96) == *(u32*)(rhs.ch+96);
13491    return retval;
13492}
13493
13494// --- algo.RspaceStr100..EqStrptr
13495inline bool algo::RspaceStr100_EqStrptr(const algo::RspaceStr100& lhs, const algo::strptr& rhs) {
13496    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13497}
13498
13499inline bool algo::RspaceStr11::operator ==(const algo::RspaceStr11 &rhs) const {
13500    return algo::RspaceStr11_Eq(const_cast<algo::RspaceStr11&>(*this),const_cast<algo::RspaceStr11&>(rhs));
13501}
13502
13503inline bool algo::RspaceStr11::operator !=(const algo::RspaceStr11 &rhs) const {
13504    return !algo::RspaceStr11_Eq(const_cast<algo::RspaceStr11&>(*this),const_cast<algo::RspaceStr11&>(rhs));
13505}
13506
13507inline bool algo::RspaceStr11::operator ==(const algo::strptr &rhs) const {
13508    return algo::RspaceStr11_EqStrptr(const_cast<algo::RspaceStr11&>(*this),rhs);
13509}
13510inline algo::RspaceStr11::RspaceStr11() {
13511    algo::RspaceStr11_Init(*this);
13512}
13513
13514
13515// --- algo.RspaceStr11.ch.Getary
13516// Access string as array of chars
13517inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr11& parent) {
13518    int len = ch_N(parent);
13519    algo::aryptr<char> ret((char*)parent.ch, len);
13520    return ret;
13521}
13522
13523// --- algo.RspaceStr11.ch.HashStrptr
13524inline u32 algo::RspaceStr11_Hash(u32 prev, const algo::strptr &str) {
13525    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13526}
13527
13528// --- algo.RspaceStr11.ch.Init
13529inline void algo::ch_Init(algo::RspaceStr11 &parent) {
13530    memset(parent.ch, ' ', 11);
13531}
13532
13533// --- algo.RspaceStr11.ch.Max
13534// always return constant 11
13535inline int algo::ch_Max(algo::RspaceStr11& parent) {
13536    (void)parent;
13537    return 11;
13538}
13539
13540// --- algo.RspaceStr11.ch.N
13541inline int algo::ch_N(const algo::RspaceStr11& parent) {
13542    u64 ret;
13543    ret = 11;
13544    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13545        ret--;
13546    }
13547    return int(ret);
13548}
13549
13550// --- algo.RspaceStr11.ch.AssignStrptr
13551// Copy from strptr (operator=)
13552inline void algo::RspaceStr11::operator =(const algo::strptr &str) {
13553    ch_SetStrptr(*this, str);
13554}
13555
13556// --- algo.RspaceStr11.ch.Set
13557// Copy from same type
13558// Copy value from RHS.
13559inline void algo::RspaceStr11::operator =(const algo::RspaceStr11& parent) {
13560    memcpy(ch, parent.ch, 11);
13561}
13562
13563// --- algo.RspaceStr11.ch.Ctor
13564inline  algo::RspaceStr11::RspaceStr11(const algo::RspaceStr11 &rhs) {
13565    operator =(rhs);
13566}
13567
13568// --- algo.RspaceStr11.ch.CtorStrptr
13569inline  algo::RspaceStr11::RspaceStr11(const algo::strptr &rhs) {
13570    ch_SetStrptr(*this, rhs);
13571}
13572
13573// --- algo.RspaceStr11.ch.Cast
13574inline algo::RspaceStr11::operator algo::strptr () const {
13575    return ch_Getary(*this);
13576}
13577
13578// --- algo.RspaceStr11..Cmp
13579inline i32 algo::RspaceStr11_Cmp(algo::RspaceStr11& lhs, algo::RspaceStr11& rhs) {
13580    i32 retval = 0;
13581    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13582    return retval;
13583}
13584
13585// --- algo.RspaceStr11..Init
13586// Set all fields to initial values.
13587inline void algo::RspaceStr11_Init(algo::RspaceStr11& parent) {
13588    memset(parent.ch, ' ', 11);
13589}
13590
13591// --- algo.RspaceStr11..Eq
13592inline bool algo::RspaceStr11_Eq(algo::RspaceStr11& lhs, algo::RspaceStr11& rhs) {
13593    bool retval = true;
13594    retval = retval
13595    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13596    &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8)
13597    &&*(u8*)(lhs.ch+10) == *(u8*)(rhs.ch+10);
13598    return retval;
13599}
13600
13601// --- algo.RspaceStr11..EqStrptr
13602inline bool algo::RspaceStr11_EqStrptr(const algo::RspaceStr11& lhs, const algo::strptr& rhs) {
13603    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13604}
13605
13606inline bool algo::RspaceStr12::operator ==(const algo::RspaceStr12 &rhs) const {
13607    return algo::RspaceStr12_Eq(const_cast<algo::RspaceStr12&>(*this),const_cast<algo::RspaceStr12&>(rhs));
13608}
13609
13610inline bool algo::RspaceStr12::operator !=(const algo::RspaceStr12 &rhs) const {
13611    return !algo::RspaceStr12_Eq(const_cast<algo::RspaceStr12&>(*this),const_cast<algo::RspaceStr12&>(rhs));
13612}
13613
13614inline bool algo::RspaceStr12::operator ==(const algo::strptr &rhs) const {
13615    return algo::RspaceStr12_EqStrptr(const_cast<algo::RspaceStr12&>(*this),rhs);
13616}
13617inline algo::RspaceStr12::RspaceStr12() {
13618    algo::RspaceStr12_Init(*this);
13619}
13620
13621
13622// --- algo.RspaceStr12.ch.Getary
13623// Access string as array of chars
13624inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr12& parent) {
13625    int len = ch_N(parent);
13626    algo::aryptr<char> ret((char*)parent.ch, len);
13627    return ret;
13628}
13629
13630// --- algo.RspaceStr12.ch.HashStrptr
13631inline u32 algo::RspaceStr12_Hash(u32 prev, const algo::strptr &str) {
13632    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13633}
13634
13635// --- algo.RspaceStr12.ch.Init
13636inline void algo::ch_Init(algo::RspaceStr12 &parent) {
13637    memset(parent.ch, ' ', 12);
13638}
13639
13640// --- algo.RspaceStr12.ch.Max
13641// always return constant 12
13642inline int algo::ch_Max(algo::RspaceStr12& parent) {
13643    (void)parent;
13644    return 12;
13645}
13646
13647// --- algo.RspaceStr12.ch.N
13648inline int algo::ch_N(const algo::RspaceStr12& parent) {
13649    u64 ret;
13650    ret = 12;
13651    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13652        ret--;
13653    }
13654    return int(ret);
13655}
13656
13657// --- algo.RspaceStr12.ch.AssignStrptr
13658// Copy from strptr (operator=)
13659inline void algo::RspaceStr12::operator =(const algo::strptr &str) {
13660    ch_SetStrptr(*this, str);
13661}
13662
13663// --- algo.RspaceStr12.ch.Set
13664// Copy from same type
13665// Copy value from RHS.
13666inline void algo::RspaceStr12::operator =(const algo::RspaceStr12& parent) {
13667    memcpy(ch, parent.ch, 12);
13668}
13669
13670// --- algo.RspaceStr12.ch.Ctor
13671inline  algo::RspaceStr12::RspaceStr12(const algo::RspaceStr12 &rhs) {
13672    operator =(rhs);
13673}
13674
13675// --- algo.RspaceStr12.ch.CtorStrptr
13676inline  algo::RspaceStr12::RspaceStr12(const algo::strptr &rhs) {
13677    ch_SetStrptr(*this, rhs);
13678}
13679
13680// --- algo.RspaceStr12.ch.Cast
13681inline algo::RspaceStr12::operator algo::strptr () const {
13682    return ch_Getary(*this);
13683}
13684
13685// --- algo.RspaceStr12..Cmp
13686inline i32 algo::RspaceStr12_Cmp(algo::RspaceStr12 lhs, algo::RspaceStr12 rhs) {
13687    i32 retval = 0;
13688    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13689    return retval;
13690}
13691
13692// --- algo.RspaceStr12..Init
13693// Set all fields to initial values.
13694inline void algo::RspaceStr12_Init(algo::RspaceStr12& parent) {
13695    memset(parent.ch, ' ', 12);
13696}
13697
13698// --- algo.RspaceStr12..Eq
13699inline bool algo::RspaceStr12_Eq(algo::RspaceStr12 lhs, algo::RspaceStr12 rhs) {
13700    bool retval = true;
13701    retval = retval
13702    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13703    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
13704    return retval;
13705}
13706
13707// --- algo.RspaceStr12..EqStrptr
13708inline bool algo::RspaceStr12_EqStrptr(algo::RspaceStr12 lhs, const algo::strptr& rhs) {
13709    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13710}
13711
13712inline bool algo::RspaceStr128::operator ==(const algo::RspaceStr128 &rhs) const {
13713    return algo::RspaceStr128_Eq(const_cast<algo::RspaceStr128&>(*this),const_cast<algo::RspaceStr128&>(rhs));
13714}
13715
13716inline bool algo::RspaceStr128::operator !=(const algo::RspaceStr128 &rhs) const {
13717    return !algo::RspaceStr128_Eq(const_cast<algo::RspaceStr128&>(*this),const_cast<algo::RspaceStr128&>(rhs));
13718}
13719
13720inline bool algo::RspaceStr128::operator ==(const algo::strptr &rhs) const {
13721    return algo::RspaceStr128_EqStrptr(const_cast<algo::RspaceStr128&>(*this),rhs);
13722}
13723inline algo::RspaceStr128::RspaceStr128() {
13724    algo::RspaceStr128_Init(*this);
13725}
13726
13727
13728// --- algo.RspaceStr128.ch.Getary
13729// Access string as array of chars
13730inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr128& parent) {
13731    int len = ch_N(parent);
13732    algo::aryptr<char> ret((char*)parent.ch, len);
13733    return ret;
13734}
13735
13736// --- algo.RspaceStr128.ch.HashStrptr
13737inline u32 algo::RspaceStr128_Hash(u32 prev, const algo::strptr &str) {
13738    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13739}
13740
13741// --- algo.RspaceStr128.ch.Init
13742inline void algo::ch_Init(algo::RspaceStr128 &parent) {
13743    memset(parent.ch, ' ', 128);
13744}
13745
13746// --- algo.RspaceStr128.ch.Max
13747// always return constant 128
13748inline int algo::ch_Max(algo::RspaceStr128& parent) {
13749    (void)parent;
13750    return 128;
13751}
13752
13753// --- algo.RspaceStr128.ch.N
13754inline int algo::ch_N(const algo::RspaceStr128& parent) {
13755    u64 ret;
13756    ret = 128;
13757    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13758        ret--;
13759    }
13760    return int(ret);
13761}
13762
13763// --- algo.RspaceStr128.ch.AssignStrptr
13764// Copy from strptr (operator=)
13765inline void algo::RspaceStr128::operator =(const algo::strptr &str) {
13766    ch_SetStrptr(*this, str);
13767}
13768
13769// --- algo.RspaceStr128.ch.Set
13770// Copy from same type
13771// Copy value from RHS.
13772inline void algo::RspaceStr128::operator =(const algo::RspaceStr128& parent) {
13773    memcpy(ch, parent.ch, 128);
13774}
13775
13776// --- algo.RspaceStr128.ch.Ctor
13777inline  algo::RspaceStr128::RspaceStr128(const algo::RspaceStr128 &rhs) {
13778    operator =(rhs);
13779}
13780
13781// --- algo.RspaceStr128.ch.CtorStrptr
13782inline  algo::RspaceStr128::RspaceStr128(const algo::strptr &rhs) {
13783    ch_SetStrptr(*this, rhs);
13784}
13785
13786// --- algo.RspaceStr128.ch.Cast
13787inline algo::RspaceStr128::operator algo::strptr () const {
13788    return ch_Getary(*this);
13789}
13790
13791// --- algo.RspaceStr128..Cmp
13792inline i32 algo::RspaceStr128_Cmp(algo::RspaceStr128 lhs, algo::RspaceStr128 rhs) {
13793    i32 retval = 0;
13794    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13795    return retval;
13796}
13797
13798// --- algo.RspaceStr128..Init
13799// Set all fields to initial values.
13800inline void algo::RspaceStr128_Init(algo::RspaceStr128& parent) {
13801    memset(parent.ch, ' ', 128);
13802}
13803
13804// --- algo.RspaceStr128..Eq
13805inline bool algo::RspaceStr128_Eq(algo::RspaceStr128 lhs, algo::RspaceStr128 rhs) {
13806    bool retval = true;
13807    retval = retval
13808    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13809    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
13810    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
13811    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
13812    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
13813    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
13814    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
13815    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
13816    &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
13817    &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72)
13818    &&*(u64*)(lhs.ch+80) == *(u64*)(rhs.ch+80)
13819    &&*(u64*)(lhs.ch+88) == *(u64*)(rhs.ch+88)
13820    &&*(u64*)(lhs.ch+96) == *(u64*)(rhs.ch+96)
13821    &&*(u64*)(lhs.ch+104) == *(u64*)(rhs.ch+104)
13822    &&*(u64*)(lhs.ch+112) == *(u64*)(rhs.ch+112)
13823    &&*(u64*)(lhs.ch+120) == *(u64*)(rhs.ch+120);
13824    return retval;
13825}
13826
13827// --- algo.RspaceStr128..EqStrptr
13828inline bool algo::RspaceStr128_EqStrptr(algo::RspaceStr128 lhs, const algo::strptr& rhs) {
13829    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13830}
13831
13832inline bool algo::RspaceStr14::operator ==(const algo::RspaceStr14 &rhs) const {
13833    return algo::RspaceStr14_Eq(const_cast<algo::RspaceStr14&>(*this),const_cast<algo::RspaceStr14&>(rhs));
13834}
13835
13836inline bool algo::RspaceStr14::operator !=(const algo::RspaceStr14 &rhs) const {
13837    return !algo::RspaceStr14_Eq(const_cast<algo::RspaceStr14&>(*this),const_cast<algo::RspaceStr14&>(rhs));
13838}
13839
13840inline bool algo::RspaceStr14::operator ==(const algo::strptr &rhs) const {
13841    return algo::RspaceStr14_EqStrptr(const_cast<algo::RspaceStr14&>(*this),rhs);
13842}
13843inline algo::RspaceStr14::RspaceStr14() {
13844    algo::RspaceStr14_Init(*this);
13845}
13846
13847
13848// --- algo.RspaceStr14.ch.Getary
13849// Access string as array of chars
13850inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr14& parent) {
13851    int len = ch_N(parent);
13852    algo::aryptr<char> ret((char*)parent.ch, len);
13853    return ret;
13854}
13855
13856// --- algo.RspaceStr14.ch.HashStrptr
13857inline u32 algo::RspaceStr14_Hash(u32 prev, const algo::strptr &str) {
13858    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13859}
13860
13861// --- algo.RspaceStr14.ch.Init
13862inline void algo::ch_Init(algo::RspaceStr14 &parent) {
13863    memset(parent.ch, ' ', 14);
13864}
13865
13866// --- algo.RspaceStr14.ch.Max
13867// always return constant 14
13868inline int algo::ch_Max(algo::RspaceStr14& parent) {
13869    (void)parent;
13870    return 14;
13871}
13872
13873// --- algo.RspaceStr14.ch.N
13874inline int algo::ch_N(const algo::RspaceStr14& parent) {
13875    u64 ret;
13876    ret = 14;
13877    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13878        ret--;
13879    }
13880    return int(ret);
13881}
13882
13883// --- algo.RspaceStr14.ch.AssignStrptr
13884// Copy from strptr (operator=)
13885inline void algo::RspaceStr14::operator =(const algo::strptr &str) {
13886    ch_SetStrptr(*this, str);
13887}
13888
13889// --- algo.RspaceStr14.ch.Set
13890// Copy from same type
13891// Copy value from RHS.
13892inline void algo::RspaceStr14::operator =(const algo::RspaceStr14& parent) {
13893    memcpy(ch, parent.ch, 14);
13894}
13895
13896// --- algo.RspaceStr14.ch.Ctor
13897inline  algo::RspaceStr14::RspaceStr14(const algo::RspaceStr14 &rhs) {
13898    operator =(rhs);
13899}
13900
13901// --- algo.RspaceStr14.ch.CtorStrptr
13902inline  algo::RspaceStr14::RspaceStr14(const algo::strptr &rhs) {
13903    ch_SetStrptr(*this, rhs);
13904}
13905
13906// --- algo.RspaceStr14.ch.Cast
13907inline algo::RspaceStr14::operator algo::strptr () const {
13908    return ch_Getary(*this);
13909}
13910
13911// --- algo.RspaceStr14..Cmp
13912inline i32 algo::RspaceStr14_Cmp(algo::RspaceStr14 lhs, algo::RspaceStr14 rhs) {
13913    i32 retval = 0;
13914    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13915    return retval;
13916}
13917
13918// --- algo.RspaceStr14..Init
13919// Set all fields to initial values.
13920inline void algo::RspaceStr14_Init(algo::RspaceStr14& parent) {
13921    memset(parent.ch, ' ', 14);
13922}
13923
13924// --- algo.RspaceStr14..Eq
13925inline bool algo::RspaceStr14_Eq(algo::RspaceStr14 lhs, algo::RspaceStr14 rhs) {
13926    bool retval = true;
13927    retval = retval
13928    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13929    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
13930    &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12);
13931    return retval;
13932}
13933
13934// --- algo.RspaceStr14..EqStrptr
13935inline bool algo::RspaceStr14_EqStrptr(algo::RspaceStr14 lhs, const algo::strptr& rhs) {
13936    return algo::strptr_Eq(ch_Getary(lhs), rhs);
13937}
13938
13939inline bool algo::RspaceStr15::operator ==(const algo::RspaceStr15 &rhs) const {
13940    return algo::RspaceStr15_Eq(const_cast<algo::RspaceStr15&>(*this),const_cast<algo::RspaceStr15&>(rhs));
13941}
13942
13943inline bool algo::RspaceStr15::operator !=(const algo::RspaceStr15 &rhs) const {
13944    return !algo::RspaceStr15_Eq(const_cast<algo::RspaceStr15&>(*this),const_cast<algo::RspaceStr15&>(rhs));
13945}
13946
13947inline bool algo::RspaceStr15::operator ==(const algo::strptr &rhs) const {
13948    return algo::RspaceStr15_EqStrptr(const_cast<algo::RspaceStr15&>(*this),rhs);
13949}
13950inline algo::RspaceStr15::RspaceStr15() {
13951    algo::RspaceStr15_Init(*this);
13952}
13953
13954
13955// --- algo.RspaceStr15.ch.Getary
13956// Access string as array of chars
13957inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr15& parent) {
13958    int len = ch_N(parent);
13959    algo::aryptr<char> ret((char*)parent.ch, len);
13960    return ret;
13961}
13962
13963// --- algo.RspaceStr15.ch.HashStrptr
13964inline u32 algo::RspaceStr15_Hash(u32 prev, const algo::strptr &str) {
13965    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13966}
13967
13968// --- algo.RspaceStr15.ch.Init
13969inline void algo::ch_Init(algo::RspaceStr15 &parent) {
13970    memset(parent.ch, ' ', 15);
13971}
13972
13973// --- algo.RspaceStr15.ch.Max
13974// always return constant 15
13975inline int algo::ch_Max(algo::RspaceStr15& parent) {
13976    (void)parent;
13977    return 15;
13978}
13979
13980// --- algo.RspaceStr15.ch.N
13981inline int algo::ch_N(const algo::RspaceStr15& parent) {
13982    u64 ret;
13983    ret = 15;
13984    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13985        ret--;
13986    }
13987    return int(ret);
13988}
13989
13990// --- algo.RspaceStr15.ch.AssignStrptr
13991// Copy from strptr (operator=)
13992inline void algo::RspaceStr15::operator =(const algo::strptr &str) {
13993    ch_SetStrptr(*this, str);
13994}
13995
13996// --- algo.RspaceStr15.ch.Set
13997// Copy from same type
13998// Copy value from RHS.
13999inline void algo::RspaceStr15::operator =(const algo::RspaceStr15& parent) {
14000    memcpy(ch, parent.ch, 15);
14001}
14002
14003// --- algo.RspaceStr15.ch.Ctor
14004inline  algo::RspaceStr15::RspaceStr15(const algo::RspaceStr15 &rhs) {
14005    operator =(rhs);
14006}
14007
14008// --- algo.RspaceStr15.ch.CtorStrptr
14009inline  algo::RspaceStr15::RspaceStr15(const algo::strptr &rhs) {
14010    ch_SetStrptr(*this, rhs);
14011}
14012
14013// --- algo.RspaceStr15.ch.Cast
14014inline algo::RspaceStr15::operator algo::strptr () const {
14015    return ch_Getary(*this);
14016}
14017
14018// --- algo.RspaceStr15..Cmp
14019inline i32 algo::RspaceStr15_Cmp(algo::RspaceStr15 lhs, algo::RspaceStr15 rhs) {
14020    i32 retval = 0;
14021    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14022    return retval;
14023}
14024
14025// --- algo.RspaceStr15..Init
14026// Set all fields to initial values.
14027inline void algo::RspaceStr15_Init(algo::RspaceStr15& parent) {
14028    memset(parent.ch, ' ', 15);
14029}
14030
14031// --- algo.RspaceStr15..Eq
14032inline bool algo::RspaceStr15_Eq(algo::RspaceStr15 lhs, algo::RspaceStr15 rhs) {
14033    bool retval = true;
14034    retval = retval
14035    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14036    &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
14037    &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12)
14038    &&*(u8*)(lhs.ch+14) == *(u8*)(rhs.ch+14);
14039    return retval;
14040}
14041
14042// --- algo.RspaceStr15..EqStrptr
14043inline bool algo::RspaceStr15_EqStrptr(algo::RspaceStr15 lhs, const algo::strptr& rhs) {
14044    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14045}
14046inline algo::RspaceStr16::RspaceStr16() {
14047    algo::RspaceStr16_Init(*this);
14048}
14049
14050
14051// --- algo.RspaceStr16.ch.Getary
14052// Access string as array of chars
14053inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr16& parent) {
14054    int len = ch_N(parent);
14055    algo::aryptr<char> ret((char*)parent.ch, len);
14056    return ret;
14057}
14058
14059// --- algo.RspaceStr16.ch.HashStrptr
14060inline u32 algo::RspaceStr16_Hash(u32 prev, const algo::strptr &str) {
14061    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14062}
14063
14064// --- algo.RspaceStr16.ch.Init
14065inline void algo::ch_Init(algo::RspaceStr16 &parent) {
14066    memset(parent.ch, ' ', 16);
14067}
14068
14069// --- algo.RspaceStr16.ch.Max
14070// always return constant 16
14071inline int algo::ch_Max(algo::RspaceStr16& parent) {
14072    (void)parent;
14073    return 16;
14074}
14075
14076// --- algo.RspaceStr16.ch.N
14077inline int algo::ch_N(const algo::RspaceStr16& parent) {
14078    u64 ret;
14079    ret = 16;
14080    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14081        ret--;
14082    }
14083    return int(ret);
14084}
14085
14086// --- algo.RspaceStr16.ch.AssignStrptr
14087// Copy from strptr (operator=)
14088inline void algo::RspaceStr16::operator =(const algo::strptr &str) {
14089    ch_SetStrptr(*this, str);
14090}
14091
14092// --- algo.RspaceStr16.ch.Set
14093// Copy from same type
14094// Copy value from RHS.
14095inline void algo::RspaceStr16::operator =(const algo::RspaceStr16& parent) {
14096    memcpy(ch, parent.ch, 16);
14097}
14098
14099// --- algo.RspaceStr16.ch.Ctor
14100inline  algo::RspaceStr16::RspaceStr16(const algo::RspaceStr16 &rhs) {
14101    operator =(rhs);
14102}
14103
14104// --- algo.RspaceStr16.ch.CtorStrptr
14105inline  algo::RspaceStr16::RspaceStr16(const algo::strptr &rhs) {
14106    ch_SetStrptr(*this, rhs);
14107}
14108
14109// --- algo.RspaceStr16.ch.Cast
14110inline algo::RspaceStr16::operator algo::strptr () const {
14111    return ch_Getary(*this);
14112}
14113
14114// --- algo.RspaceStr16..Lt
14115inline bool algo::RspaceStr16_Lt(algo::RspaceStr16 lhs, algo::RspaceStr16 rhs) {
14116    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
14117}
14118
14119// --- algo.RspaceStr16..Cmp
14120inline i32 algo::RspaceStr16_Cmp(algo::RspaceStr16 lhs, algo::RspaceStr16 rhs) {
14121    i32 retval = 0;
14122    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14123    return retval;
14124}
14125
14126// --- algo.RspaceStr16..Init
14127// Set all fields to initial values.
14128inline void algo::RspaceStr16_Init(algo::RspaceStr16& parent) {
14129    memset(parent.ch, ' ', 16);
14130}
14131
14132// --- algo.RspaceStr16..Eq
14133inline bool algo::RspaceStr16_Eq(algo::RspaceStr16 lhs, algo::RspaceStr16 rhs) {
14134    bool retval = true;
14135    retval = retval
14136    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14137    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8);
14138    return retval;
14139}
14140
14141// --- algo.RspaceStr16..Update
14142// Set value. Return true if new value is different from old value.
14143inline bool algo::RspaceStr16_Update(algo::RspaceStr16 &lhs, algo::RspaceStr16 rhs) {
14144    bool ret = !RspaceStr16_Eq(lhs, rhs); // compare values
14145    if (ret) {
14146        lhs = rhs; // update
14147    }
14148    return ret;
14149}
14150
14151// --- algo.RspaceStr16..EqStrptr
14152inline bool algo::RspaceStr16_EqStrptr(algo::RspaceStr16 lhs, const algo::strptr& rhs) {
14153    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14154}
14155
14156inline bool algo::RspaceStr18::operator ==(const algo::RspaceStr18 &rhs) const {
14157    return algo::RspaceStr18_Eq(const_cast<algo::RspaceStr18&>(*this),const_cast<algo::RspaceStr18&>(rhs));
14158}
14159
14160inline bool algo::RspaceStr18::operator !=(const algo::RspaceStr18 &rhs) const {
14161    return !algo::RspaceStr18_Eq(const_cast<algo::RspaceStr18&>(*this),const_cast<algo::RspaceStr18&>(rhs));
14162}
14163
14164inline bool algo::RspaceStr18::operator ==(const algo::strptr &rhs) const {
14165    return algo::RspaceStr18_EqStrptr(const_cast<algo::RspaceStr18&>(*this),rhs);
14166}
14167inline algo::RspaceStr18::RspaceStr18() {
14168    algo::RspaceStr18_Init(*this);
14169}
14170
14171
14172// --- algo.RspaceStr18.ch.Getary
14173// Access string as array of chars
14174inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr18& parent) {
14175    int len = ch_N(parent);
14176    algo::aryptr<char> ret((char*)parent.ch, len);
14177    return ret;
14178}
14179
14180// --- algo.RspaceStr18.ch.HashStrptr
14181inline u32 algo::RspaceStr18_Hash(u32 prev, const algo::strptr &str) {
14182    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14183}
14184
14185// --- algo.RspaceStr18.ch.Init
14186inline void algo::ch_Init(algo::RspaceStr18 &parent) {
14187    memset(parent.ch, ' ', 18);
14188}
14189
14190// --- algo.RspaceStr18.ch.Max
14191// always return constant 18
14192inline int algo::ch_Max(algo::RspaceStr18& parent) {
14193    (void)parent;
14194    return 18;
14195}
14196
14197// --- algo.RspaceStr18.ch.N
14198inline int algo::ch_N(const algo::RspaceStr18& parent) {
14199    u64 ret;
14200    ret = 18;
14201    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14202        ret--;
14203    }
14204    return int(ret);
14205}
14206
14207// --- algo.RspaceStr18.ch.AssignStrptr
14208// Copy from strptr (operator=)
14209inline void algo::RspaceStr18::operator =(const algo::strptr &str) {
14210    ch_SetStrptr(*this, str);
14211}
14212
14213// --- algo.RspaceStr18.ch.Set
14214// Copy from same type
14215// Copy value from RHS.
14216inline void algo::RspaceStr18::operator =(const algo::RspaceStr18& parent) {
14217    memcpy(ch, parent.ch, 18);
14218}
14219
14220// --- algo.RspaceStr18.ch.Ctor
14221inline  algo::RspaceStr18::RspaceStr18(const algo::RspaceStr18 &rhs) {
14222    operator =(rhs);
14223}
14224
14225// --- algo.RspaceStr18.ch.CtorStrptr
14226inline  algo::RspaceStr18::RspaceStr18(const algo::strptr &rhs) {
14227    ch_SetStrptr(*this, rhs);
14228}
14229
14230// --- algo.RspaceStr18.ch.Cast
14231inline algo::RspaceStr18::operator algo::strptr () const {
14232    return ch_Getary(*this);
14233}
14234
14235// --- algo.RspaceStr18..Cmp
14236inline i32 algo::RspaceStr18_Cmp(algo::RspaceStr18 lhs, algo::RspaceStr18 rhs) {
14237    i32 retval = 0;
14238    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14239    return retval;
14240}
14241
14242// --- algo.RspaceStr18..Init
14243// Set all fields to initial values.
14244inline void algo::RspaceStr18_Init(algo::RspaceStr18& parent) {
14245    memset(parent.ch, ' ', 18);
14246}
14247
14248// --- algo.RspaceStr18..Eq
14249inline bool algo::RspaceStr18_Eq(algo::RspaceStr18 lhs, algo::RspaceStr18 rhs) {
14250    bool retval = true;
14251    retval = retval
14252    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14253    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14254    &&*(u16*)(lhs.ch+16) == *(u16*)(rhs.ch+16);
14255    return retval;
14256}
14257
14258// --- algo.RspaceStr18..EqStrptr
14259inline bool algo::RspaceStr18_EqStrptr(algo::RspaceStr18 lhs, const algo::strptr& rhs) {
14260    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14261}
14262
14263inline bool algo::RspaceStr2::operator ==(const algo::RspaceStr2 &rhs) const {
14264    return algo::RspaceStr2_Eq(const_cast<algo::RspaceStr2&>(*this),const_cast<algo::RspaceStr2&>(rhs));
14265}
14266
14267inline bool algo::RspaceStr2::operator !=(const algo::RspaceStr2 &rhs) const {
14268    return !algo::RspaceStr2_Eq(const_cast<algo::RspaceStr2&>(*this),const_cast<algo::RspaceStr2&>(rhs));
14269}
14270
14271inline bool algo::RspaceStr2::operator ==(const algo::strptr &rhs) const {
14272    return algo::RspaceStr2_EqStrptr(const_cast<algo::RspaceStr2&>(*this),rhs);
14273}
14274inline algo::RspaceStr2::RspaceStr2() {
14275    algo::RspaceStr2_Init(*this);
14276}
14277
14278
14279// --- algo.RspaceStr2.ch.Getary
14280// Access string as array of chars
14281inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr2& parent) {
14282    int len = ch_N(parent);
14283    algo::aryptr<char> ret((char*)parent.ch, len);
14284    return ret;
14285}
14286
14287// --- algo.RspaceStr2.ch.HashStrptr
14288inline u32 algo::RspaceStr2_Hash(u32 prev, const algo::strptr &str) {
14289    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14290}
14291
14292// --- algo.RspaceStr2.ch.Init
14293inline void algo::ch_Init(algo::RspaceStr2 &parent) {
14294    memset(parent.ch, ' ', 2);
14295}
14296
14297// --- algo.RspaceStr2.ch.Max
14298// always return constant 2
14299inline int algo::ch_Max(algo::RspaceStr2& parent) {
14300    (void)parent;
14301    return 2;
14302}
14303
14304// --- algo.RspaceStr2.ch.N
14305inline int algo::ch_N(const algo::RspaceStr2& parent) {
14306    u64 ret;
14307    ret = 2;
14308    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14309        ret--;
14310    }
14311    return int(ret);
14312}
14313
14314// --- algo.RspaceStr2.ch.AssignStrptr
14315// Copy from strptr (operator=)
14316inline void algo::RspaceStr2::operator =(const algo::strptr &str) {
14317    ch_SetStrptr(*this, str);
14318}
14319
14320// --- algo.RspaceStr2.ch.Set
14321// Copy from same type
14322// Copy value from RHS.
14323inline void algo::RspaceStr2::operator =(const algo::RspaceStr2& parent) {
14324    memcpy(ch, parent.ch, 2);
14325}
14326
14327// --- algo.RspaceStr2.ch.Ctor
14328inline  algo::RspaceStr2::RspaceStr2(const algo::RspaceStr2 &rhs) {
14329    operator =(rhs);
14330}
14331
14332// --- algo.RspaceStr2.ch.CtorStrptr
14333inline  algo::RspaceStr2::RspaceStr2(const algo::strptr &rhs) {
14334    ch_SetStrptr(*this, rhs);
14335}
14336
14337// --- algo.RspaceStr2.ch.Cast
14338inline algo::RspaceStr2::operator algo::strptr () const {
14339    return ch_Getary(*this);
14340}
14341
14342// --- algo.RspaceStr2..Cmp
14343inline i32 algo::RspaceStr2_Cmp(algo::RspaceStr2 lhs, algo::RspaceStr2 rhs) {
14344    i32 retval = 0;
14345    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14346    return retval;
14347}
14348
14349// --- algo.RspaceStr2..Init
14350// Set all fields to initial values.
14351inline void algo::RspaceStr2_Init(algo::RspaceStr2& parent) {
14352    memset(parent.ch, ' ', 2);
14353}
14354
14355// --- algo.RspaceStr2..Eq
14356inline bool algo::RspaceStr2_Eq(algo::RspaceStr2 lhs, algo::RspaceStr2 rhs) {
14357    bool retval = true;
14358    retval = retval
14359    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0);
14360    return retval;
14361}
14362
14363// --- algo.RspaceStr2..EqStrptr
14364inline bool algo::RspaceStr2_EqStrptr(algo::RspaceStr2 lhs, const algo::strptr& rhs) {
14365    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14366}
14367
14368inline bool algo::RspaceStr20::operator ==(const algo::RspaceStr20 &rhs) const {
14369    return algo::RspaceStr20_Eq(const_cast<algo::RspaceStr20&>(*this),const_cast<algo::RspaceStr20&>(rhs));
14370}
14371
14372inline bool algo::RspaceStr20::operator !=(const algo::RspaceStr20 &rhs) const {
14373    return !algo::RspaceStr20_Eq(const_cast<algo::RspaceStr20&>(*this),const_cast<algo::RspaceStr20&>(rhs));
14374}
14375
14376inline bool algo::RspaceStr20::operator ==(const algo::strptr &rhs) const {
14377    return algo::RspaceStr20_EqStrptr(const_cast<algo::RspaceStr20&>(*this),rhs);
14378}
14379inline algo::RspaceStr20::RspaceStr20() {
14380    algo::RspaceStr20_Init(*this);
14381}
14382
14383
14384// --- algo.RspaceStr20.ch.Getary
14385// Access string as array of chars
14386inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr20& parent) {
14387    int len = ch_N(parent);
14388    algo::aryptr<char> ret((char*)parent.ch, len);
14389    return ret;
14390}
14391
14392// --- algo.RspaceStr20.ch.HashStrptr
14393inline u32 algo::RspaceStr20_Hash(u32 prev, const algo::strptr &str) {
14394    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14395}
14396
14397// --- algo.RspaceStr20.ch.Init
14398inline void algo::ch_Init(algo::RspaceStr20 &parent) {
14399    memset(parent.ch, ' ', 20);
14400}
14401
14402// --- algo.RspaceStr20.ch.Max
14403// always return constant 20
14404inline int algo::ch_Max(algo::RspaceStr20& parent) {
14405    (void)parent;
14406    return 20;
14407}
14408
14409// --- algo.RspaceStr20.ch.N
14410inline int algo::ch_N(const algo::RspaceStr20& parent) {
14411    u64 ret;
14412    ret = 20;
14413    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14414        ret--;
14415    }
14416    return int(ret);
14417}
14418
14419// --- algo.RspaceStr20.ch.AssignStrptr
14420// Copy from strptr (operator=)
14421inline void algo::RspaceStr20::operator =(const algo::strptr &str) {
14422    ch_SetStrptr(*this, str);
14423}
14424
14425// --- algo.RspaceStr20.ch.Set
14426// Copy from same type
14427// Copy value from RHS.
14428inline void algo::RspaceStr20::operator =(const algo::RspaceStr20& parent) {
14429    memcpy(ch, parent.ch, 20);
14430}
14431
14432// --- algo.RspaceStr20.ch.Ctor
14433inline  algo::RspaceStr20::RspaceStr20(const algo::RspaceStr20 &rhs) {
14434    operator =(rhs);
14435}
14436
14437// --- algo.RspaceStr20.ch.CtorStrptr
14438inline  algo::RspaceStr20::RspaceStr20(const algo::strptr &rhs) {
14439    ch_SetStrptr(*this, rhs);
14440}
14441
14442// --- algo.RspaceStr20.ch.Cast
14443inline algo::RspaceStr20::operator algo::strptr () const {
14444    return ch_Getary(*this);
14445}
14446
14447// --- algo.RspaceStr20..Cmp
14448inline i32 algo::RspaceStr20_Cmp(algo::RspaceStr20 lhs, algo::RspaceStr20 rhs) {
14449    i32 retval = 0;
14450    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14451    return retval;
14452}
14453
14454// --- algo.RspaceStr20..Init
14455// Set all fields to initial values.
14456inline void algo::RspaceStr20_Init(algo::RspaceStr20& parent) {
14457    memset(parent.ch, ' ', 20);
14458}
14459
14460// --- algo.RspaceStr20..Eq
14461inline bool algo::RspaceStr20_Eq(algo::RspaceStr20 lhs, algo::RspaceStr20 rhs) {
14462    bool retval = true;
14463    retval = retval
14464    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14465    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14466    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
14467    return retval;
14468}
14469
14470// --- algo.RspaceStr20..EqStrptr
14471inline bool algo::RspaceStr20_EqStrptr(algo::RspaceStr20 lhs, const algo::strptr& rhs) {
14472    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14473}
14474
14475inline bool algo::RspaceStr200::operator ==(const algo::RspaceStr200 &rhs) const {
14476    return algo::RspaceStr200_Eq(const_cast<algo::RspaceStr200&>(*this),const_cast<algo::RspaceStr200&>(rhs));
14477}
14478
14479inline bool algo::RspaceStr200::operator !=(const algo::RspaceStr200 &rhs) const {
14480    return !algo::RspaceStr200_Eq(const_cast<algo::RspaceStr200&>(*this),const_cast<algo::RspaceStr200&>(rhs));
14481}
14482
14483inline bool algo::RspaceStr200::operator ==(const algo::strptr &rhs) const {
14484    return algo::RspaceStr200_EqStrptr(const_cast<algo::RspaceStr200&>(*this),rhs);
14485}
14486inline algo::RspaceStr200::RspaceStr200() {
14487    algo::RspaceStr200_Init(*this);
14488}
14489
14490
14491// --- algo.RspaceStr200.ch.Getary
14492// Access string as array of chars
14493inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr200& parent) {
14494    int len = ch_N(parent);
14495    algo::aryptr<char> ret((char*)parent.ch, len);
14496    return ret;
14497}
14498
14499// --- algo.RspaceStr200.ch.HashStrptr
14500inline u32 algo::RspaceStr200_Hash(u32 prev, const algo::strptr &str) {
14501    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14502}
14503
14504// --- algo.RspaceStr200.ch.Init
14505inline void algo::ch_Init(algo::RspaceStr200 &parent) {
14506    memset(parent.ch, ' ', 200);
14507}
14508
14509// --- algo.RspaceStr200.ch.Max
14510// always return constant 200
14511inline int algo::ch_Max(algo::RspaceStr200& parent) {
14512    (void)parent;
14513    return 200;
14514}
14515
14516// --- algo.RspaceStr200.ch.N
14517inline int algo::ch_N(const algo::RspaceStr200& parent) {
14518    u64 ret;
14519    ret = 200;
14520    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14521        ret--;
14522    }
14523    return int(ret);
14524}
14525
14526// --- algo.RspaceStr200.ch.AssignStrptr
14527// Copy from strptr (operator=)
14528inline void algo::RspaceStr200::operator =(const algo::strptr &str) {
14529    ch_SetStrptr(*this, str);
14530}
14531
14532// --- algo.RspaceStr200.ch.Set
14533// Copy from same type
14534// Copy value from RHS.
14535inline void algo::RspaceStr200::operator =(const algo::RspaceStr200& parent) {
14536    memcpy(ch, parent.ch, 200);
14537}
14538
14539// --- algo.RspaceStr200.ch.Ctor
14540inline  algo::RspaceStr200::RspaceStr200(const algo::RspaceStr200 &rhs) {
14541    operator =(rhs);
14542}
14543
14544// --- algo.RspaceStr200.ch.CtorStrptr
14545inline  algo::RspaceStr200::RspaceStr200(const algo::strptr &rhs) {
14546    ch_SetStrptr(*this, rhs);
14547}
14548
14549// --- algo.RspaceStr200.ch.Cast
14550inline algo::RspaceStr200::operator algo::strptr () const {
14551    return ch_Getary(*this);
14552}
14553
14554// --- algo.RspaceStr200..Cmp
14555inline i32 algo::RspaceStr200_Cmp(algo::RspaceStr200& lhs, algo::RspaceStr200& rhs) {
14556    i32 retval = 0;
14557    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14558    return retval;
14559}
14560
14561// --- algo.RspaceStr200..Init
14562// Set all fields to initial values.
14563inline void algo::RspaceStr200_Init(algo::RspaceStr200& parent) {
14564    memset(parent.ch, ' ', 200);
14565}
14566
14567// --- algo.RspaceStr200..Eq
14568inline bool algo::RspaceStr200_Eq(algo::RspaceStr200& lhs, algo::RspaceStr200& rhs) {
14569    bool retval = true;
14570    for (int i=0; i<25 && retval; i++) {
14571        retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
14572    }
14573    return retval;
14574}
14575
14576// --- algo.RspaceStr200..EqStrptr
14577inline bool algo::RspaceStr200_EqStrptr(const algo::RspaceStr200& lhs, const algo::strptr& rhs) {
14578    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14579}
14580
14581inline bool algo::RspaceStr21::operator ==(const algo::RspaceStr21 &rhs) const {
14582    return algo::RspaceStr21_Eq(const_cast<algo::RspaceStr21&>(*this),const_cast<algo::RspaceStr21&>(rhs));
14583}
14584
14585inline bool algo::RspaceStr21::operator !=(const algo::RspaceStr21 &rhs) const {
14586    return !algo::RspaceStr21_Eq(const_cast<algo::RspaceStr21&>(*this),const_cast<algo::RspaceStr21&>(rhs));
14587}
14588
14589inline bool algo::RspaceStr21::operator ==(const algo::strptr &rhs) const {
14590    return algo::RspaceStr21_EqStrptr(const_cast<algo::RspaceStr21&>(*this),rhs);
14591}
14592inline algo::RspaceStr21::RspaceStr21() {
14593    algo::RspaceStr21_Init(*this);
14594}
14595
14596
14597// --- algo.RspaceStr21.ch.Getary
14598// Access string as array of chars
14599inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr21& parent) {
14600    int len = ch_N(parent);
14601    algo::aryptr<char> ret((char*)parent.ch, len);
14602    return ret;
14603}
14604
14605// --- algo.RspaceStr21.ch.HashStrptr
14606inline u32 algo::RspaceStr21_Hash(u32 prev, const algo::strptr &str) {
14607    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14608}
14609
14610// --- algo.RspaceStr21.ch.Init
14611inline void algo::ch_Init(algo::RspaceStr21 &parent) {
14612    memset(parent.ch, ' ', 21);
14613}
14614
14615// --- algo.RspaceStr21.ch.Max
14616// always return constant 21
14617inline int algo::ch_Max(algo::RspaceStr21& parent) {
14618    (void)parent;
14619    return 21;
14620}
14621
14622// --- algo.RspaceStr21.ch.N
14623inline int algo::ch_N(const algo::RspaceStr21& parent) {
14624    u64 ret;
14625    ret = 21;
14626    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14627        ret--;
14628    }
14629    return int(ret);
14630}
14631
14632// --- algo.RspaceStr21.ch.AssignStrptr
14633// Copy from strptr (operator=)
14634inline void algo::RspaceStr21::operator =(const algo::strptr &str) {
14635    ch_SetStrptr(*this, str);
14636}
14637
14638// --- algo.RspaceStr21.ch.Set
14639// Copy from same type
14640// Copy value from RHS.
14641inline void algo::RspaceStr21::operator =(const algo::RspaceStr21& parent) {
14642    memcpy(ch, parent.ch, 21);
14643}
14644
14645// --- algo.RspaceStr21.ch.Ctor
14646inline  algo::RspaceStr21::RspaceStr21(const algo::RspaceStr21 &rhs) {
14647    operator =(rhs);
14648}
14649
14650// --- algo.RspaceStr21.ch.CtorStrptr
14651inline  algo::RspaceStr21::RspaceStr21(const algo::strptr &rhs) {
14652    ch_SetStrptr(*this, rhs);
14653}
14654
14655// --- algo.RspaceStr21.ch.Cast
14656inline algo::RspaceStr21::operator algo::strptr () const {
14657    return ch_Getary(*this);
14658}
14659
14660// --- algo.RspaceStr21..Cmp
14661inline i32 algo::RspaceStr21_Cmp(algo::RspaceStr21& lhs, algo::RspaceStr21& rhs) {
14662    i32 retval = 0;
14663    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14664    return retval;
14665}
14666
14667// --- algo.RspaceStr21..Init
14668// Set all fields to initial values.
14669inline void algo::RspaceStr21_Init(algo::RspaceStr21& parent) {
14670    memset(parent.ch, ' ', 21);
14671}
14672
14673// --- algo.RspaceStr21..Eq
14674inline bool algo::RspaceStr21_Eq(algo::RspaceStr21& lhs, algo::RspaceStr21& rhs) {
14675    bool retval = true;
14676    retval = retval
14677    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14678    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14679    &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16)
14680    &&*(u8*)(lhs.ch+20) == *(u8*)(rhs.ch+20);
14681    return retval;
14682}
14683
14684// --- algo.RspaceStr21..EqStrptr
14685inline bool algo::RspaceStr21_EqStrptr(const algo::RspaceStr21& lhs, const algo::strptr& rhs) {
14686    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14687}
14688inline algo::RspaceStr24::RspaceStr24() {
14689    algo::RspaceStr24_Init(*this);
14690}
14691
14692
14693// --- algo.RspaceStr24.ch.Getary
14694// Access string as array of chars
14695inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr24& parent) {
14696    int len = ch_N(parent);
14697    algo::aryptr<char> ret((char*)parent.ch, len);
14698    return ret;
14699}
14700
14701// --- algo.RspaceStr24.ch.HashStrptr
14702inline u32 algo::RspaceStr24_Hash(u32 prev, const algo::strptr &str) {
14703    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14704}
14705
14706// --- algo.RspaceStr24.ch.Init
14707inline void algo::ch_Init(algo::RspaceStr24 &parent) {
14708    memset(parent.ch, ' ', 24);
14709}
14710
14711// --- algo.RspaceStr24.ch.Max
14712// always return constant 24
14713inline int algo::ch_Max(algo::RspaceStr24& parent) {
14714    (void)parent;
14715    return 24;
14716}
14717
14718// --- algo.RspaceStr24.ch.N
14719inline int algo::ch_N(const algo::RspaceStr24& parent) {
14720    u64 ret;
14721    ret = 24;
14722    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14723        ret--;
14724    }
14725    return int(ret);
14726}
14727
14728// --- algo.RspaceStr24.ch.AssignStrptr
14729// Copy from strptr (operator=)
14730inline void algo::RspaceStr24::operator =(const algo::strptr &str) {
14731    ch_SetStrptr(*this, str);
14732}
14733
14734// --- algo.RspaceStr24.ch.Set
14735// Copy from same type
14736// Copy value from RHS.
14737inline void algo::RspaceStr24::operator =(const algo::RspaceStr24& parent) {
14738    memcpy(ch, parent.ch, 24);
14739}
14740
14741// --- algo.RspaceStr24.ch.Ctor
14742inline  algo::RspaceStr24::RspaceStr24(const algo::RspaceStr24 &rhs) {
14743    operator =(rhs);
14744}
14745
14746// --- algo.RspaceStr24.ch.CtorStrptr
14747inline  algo::RspaceStr24::RspaceStr24(const algo::strptr &rhs) {
14748    ch_SetStrptr(*this, rhs);
14749}
14750
14751// --- algo.RspaceStr24.ch.Cast
14752inline algo::RspaceStr24::operator algo::strptr () const {
14753    return ch_Getary(*this);
14754}
14755
14756// --- algo.RspaceStr24..Lt
14757inline bool algo::RspaceStr24_Lt(algo::RspaceStr24 lhs, algo::RspaceStr24 rhs) {
14758    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
14759}
14760
14761// --- algo.RspaceStr24..Cmp
14762inline i32 algo::RspaceStr24_Cmp(algo::RspaceStr24 lhs, algo::RspaceStr24 rhs) {
14763    i32 retval = 0;
14764    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14765    return retval;
14766}
14767
14768// --- algo.RspaceStr24..Init
14769// Set all fields to initial values.
14770inline void algo::RspaceStr24_Init(algo::RspaceStr24& parent) {
14771    memset(parent.ch, ' ', 24);
14772}
14773
14774// --- algo.RspaceStr24..Eq
14775inline bool algo::RspaceStr24_Eq(algo::RspaceStr24 lhs, algo::RspaceStr24 rhs) {
14776    bool retval = true;
14777    retval = retval
14778    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14779    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14780    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16);
14781    return retval;
14782}
14783
14784// --- algo.RspaceStr24..Update
14785// Set value. Return true if new value is different from old value.
14786inline bool algo::RspaceStr24_Update(algo::RspaceStr24 &lhs, algo::RspaceStr24 rhs) {
14787    bool ret = !RspaceStr24_Eq(lhs, rhs); // compare values
14788    if (ret) {
14789        lhs = rhs; // update
14790    }
14791    return ret;
14792}
14793
14794// --- algo.RspaceStr24..EqStrptr
14795inline bool algo::RspaceStr24_EqStrptr(algo::RspaceStr24 lhs, const algo::strptr& rhs) {
14796    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14797}
14798
14799inline bool algo::RspaceStr240::operator ==(const algo::RspaceStr240 &rhs) const {
14800    return algo::RspaceStr240_Eq(const_cast<algo::RspaceStr240&>(*this),const_cast<algo::RspaceStr240&>(rhs));
14801}
14802
14803inline bool algo::RspaceStr240::operator !=(const algo::RspaceStr240 &rhs) const {
14804    return !algo::RspaceStr240_Eq(const_cast<algo::RspaceStr240&>(*this),const_cast<algo::RspaceStr240&>(rhs));
14805}
14806
14807inline bool algo::RspaceStr240::operator ==(const algo::strptr &rhs) const {
14808    return algo::RspaceStr240_EqStrptr(const_cast<algo::RspaceStr240&>(*this),rhs);
14809}
14810inline algo::RspaceStr240::RspaceStr240() {
14811    algo::RspaceStr240_Init(*this);
14812}
14813
14814
14815// --- algo.RspaceStr240.ch.Getary
14816// Access string as array of chars
14817inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr240& parent) {
14818    int len = ch_N(parent);
14819    algo::aryptr<char> ret((char*)parent.ch, len);
14820    return ret;
14821}
14822
14823// --- algo.RspaceStr240.ch.HashStrptr
14824inline u32 algo::RspaceStr240_Hash(u32 prev, const algo::strptr &str) {
14825    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14826}
14827
14828// --- algo.RspaceStr240.ch.Init
14829inline void algo::ch_Init(algo::RspaceStr240 &parent) {
14830    memset(parent.ch, ' ', 240);
14831}
14832
14833// --- algo.RspaceStr240.ch.Max
14834// always return constant 240
14835inline int algo::ch_Max(algo::RspaceStr240& parent) {
14836    (void)parent;
14837    return 240;
14838}
14839
14840// --- algo.RspaceStr240.ch.N
14841inline int algo::ch_N(const algo::RspaceStr240& parent) {
14842    u64 ret;
14843    ret = 240;
14844    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14845        ret--;
14846    }
14847    return int(ret);
14848}
14849
14850// --- algo.RspaceStr240.ch.AssignStrptr
14851// Copy from strptr (operator=)
14852inline void algo::RspaceStr240::operator =(const algo::strptr &str) {
14853    ch_SetStrptr(*this, str);
14854}
14855
14856// --- algo.RspaceStr240.ch.Set
14857// Copy from same type
14858// Copy value from RHS.
14859inline void algo::RspaceStr240::operator =(const algo::RspaceStr240& parent) {
14860    memcpy(ch, parent.ch, 240);
14861}
14862
14863// --- algo.RspaceStr240.ch.Ctor
14864inline  algo::RspaceStr240::RspaceStr240(const algo::RspaceStr240 &rhs) {
14865    operator =(rhs);
14866}
14867
14868// --- algo.RspaceStr240.ch.CtorStrptr
14869inline  algo::RspaceStr240::RspaceStr240(const algo::strptr &rhs) {
14870    ch_SetStrptr(*this, rhs);
14871}
14872
14873// --- algo.RspaceStr240.ch.Cast
14874inline algo::RspaceStr240::operator algo::strptr () const {
14875    return ch_Getary(*this);
14876}
14877
14878// --- algo.RspaceStr240..Cmp
14879inline i32 algo::RspaceStr240_Cmp(algo::RspaceStr240& lhs, algo::RspaceStr240& rhs) {
14880    i32 retval = 0;
14881    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14882    return retval;
14883}
14884
14885// --- algo.RspaceStr240..Init
14886// Set all fields to initial values.
14887inline void algo::RspaceStr240_Init(algo::RspaceStr240& parent) {
14888    memset(parent.ch, ' ', 240);
14889}
14890
14891// --- algo.RspaceStr240..Eq
14892inline bool algo::RspaceStr240_Eq(algo::RspaceStr240& lhs, algo::RspaceStr240& rhs) {
14893    bool retval = true;
14894    for (int i=0; i<30 && retval; i++) {
14895        retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
14896    }
14897    return retval;
14898}
14899
14900// --- algo.RspaceStr240..EqStrptr
14901inline bool algo::RspaceStr240_EqStrptr(const algo::RspaceStr240& lhs, const algo::strptr& rhs) {
14902    return algo::strptr_Eq(ch_Getary(lhs), rhs);
14903}
14904inline algo::RspaceStr25::RspaceStr25() {
14905    algo::RspaceStr25_Init(*this);
14906}
14907
14908
14909// --- algo.RspaceStr25.ch.Getary
14910// Access string as array of chars
14911inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr25& parent) {
14912    int len = ch_N(parent);
14913    algo::aryptr<char> ret((char*)parent.ch, len);
14914    return ret;
14915}
14916
14917// --- algo.RspaceStr25.ch.HashStrptr
14918inline u32 algo::RspaceStr25_Hash(u32 prev, const algo::strptr &str) {
14919    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14920}
14921
14922// --- algo.RspaceStr25.ch.Init
14923inline void algo::ch_Init(algo::RspaceStr25 &parent) {
14924    memset(parent.ch, ' ', 25);
14925}
14926
14927// --- algo.RspaceStr25.ch.Max
14928// always return constant 25
14929inline int algo::ch_Max(algo::RspaceStr25& parent) {
14930    (void)parent;
14931    return 25;
14932}
14933
14934// --- algo.RspaceStr25.ch.N
14935inline int algo::ch_N(const algo::RspaceStr25& parent) {
14936    u64 ret;
14937    ret = 25;
14938    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14939        ret--;
14940    }
14941    return int(ret);
14942}
14943
14944// --- algo.RspaceStr25.ch.AssignStrptr
14945// Copy from strptr (operator=)
14946inline void algo::RspaceStr25::operator =(const algo::strptr &str) {
14947    ch_SetStrptr(*this, str);
14948}
14949
14950// --- algo.RspaceStr25.ch.Set
14951// Copy from same type
14952// Copy value from RHS.
14953inline void algo::RspaceStr25::operator =(const algo::RspaceStr25& parent) {
14954    memcpy(ch, parent.ch, 25);
14955}
14956
14957// --- algo.RspaceStr25.ch.Ctor
14958inline  algo::RspaceStr25::RspaceStr25(const algo::RspaceStr25 &rhs) {
14959    operator =(rhs);
14960}
14961
14962// --- algo.RspaceStr25.ch.CtorStrptr
14963inline  algo::RspaceStr25::RspaceStr25(const algo::strptr &rhs) {
14964    ch_SetStrptr(*this, rhs);
14965}
14966
14967// --- algo.RspaceStr25.ch.Cast
14968inline algo::RspaceStr25::operator algo::strptr () const {
14969    return ch_Getary(*this);
14970}
14971
14972// --- algo.RspaceStr25..Lt
14973inline bool algo::RspaceStr25_Lt(algo::RspaceStr25 lhs, algo::RspaceStr25 rhs) {
14974    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
14975}
14976
14977// --- algo.RspaceStr25..Cmp
14978inline i32 algo::RspaceStr25_Cmp(algo::RspaceStr25 lhs, algo::RspaceStr25 rhs) {
14979    i32 retval = 0;
14980    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14981    return retval;
14982}
14983
14984// --- algo.RspaceStr25..Init
14985// Set all fields to initial values.
14986inline void algo::RspaceStr25_Init(algo::RspaceStr25& parent) {
14987    memset(parent.ch, ' ', 25);
14988}
14989
14990// --- algo.RspaceStr25..Eq
14991inline bool algo::RspaceStr25_Eq(algo::RspaceStr25 lhs, algo::RspaceStr25 rhs) {
14992    bool retval = true;
14993    retval = retval
14994    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14995    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14996    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
14997    &&*(u8*)(lhs.ch+24) == *(u8*)(rhs.ch+24);
14998    return retval;
14999}
15000
15001// --- algo.RspaceStr25..Update
15002// Set value. Return true if new value is different from old value.
15003inline bool algo::RspaceStr25_Update(algo::RspaceStr25 &lhs, algo::RspaceStr25 rhs) {
15004    bool ret = !RspaceStr25_Eq(lhs, rhs); // compare values
15005    if (ret) {
15006        lhs = rhs; // update
15007    }
15008    return ret;
15009}
15010
15011// --- algo.RspaceStr25..EqStrptr
15012inline bool algo::RspaceStr25_EqStrptr(algo::RspaceStr25 lhs, const algo::strptr& rhs) {
15013    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15014}
15015
15016inline bool algo::RspaceStr26::operator ==(const algo::RspaceStr26 &rhs) const {
15017    return algo::RspaceStr26_Eq(const_cast<algo::RspaceStr26&>(*this),const_cast<algo::RspaceStr26&>(rhs));
15018}
15019
15020inline bool algo::RspaceStr26::operator !=(const algo::RspaceStr26 &rhs) const {
15021    return !algo::RspaceStr26_Eq(const_cast<algo::RspaceStr26&>(*this),const_cast<algo::RspaceStr26&>(rhs));
15022}
15023
15024inline bool algo::RspaceStr26::operator ==(const algo::strptr &rhs) const {
15025    return algo::RspaceStr26_EqStrptr(const_cast<algo::RspaceStr26&>(*this),rhs);
15026}
15027inline algo::RspaceStr26::RspaceStr26() {
15028    algo::RspaceStr26_Init(*this);
15029}
15030
15031
15032// --- algo.RspaceStr26.ch.Getary
15033// Access string as array of chars
15034inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr26& parent) {
15035    int len = ch_N(parent);
15036    algo::aryptr<char> ret((char*)parent.ch, len);
15037    return ret;
15038}
15039
15040// --- algo.RspaceStr26.ch.HashStrptr
15041inline u32 algo::RspaceStr26_Hash(u32 prev, const algo::strptr &str) {
15042    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15043}
15044
15045// --- algo.RspaceStr26.ch.Init
15046inline void algo::ch_Init(algo::RspaceStr26 &parent) {
15047    memset(parent.ch, ' ', 26);
15048}
15049
15050// --- algo.RspaceStr26.ch.Max
15051// always return constant 26
15052inline int algo::ch_Max(algo::RspaceStr26& parent) {
15053    (void)parent;
15054    return 26;
15055}
15056
15057// --- algo.RspaceStr26.ch.N
15058inline int algo::ch_N(const algo::RspaceStr26& parent) {
15059    u64 ret;
15060    ret = 26;
15061    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15062        ret--;
15063    }
15064    return int(ret);
15065}
15066
15067// --- algo.RspaceStr26.ch.AssignStrptr
15068// Copy from strptr (operator=)
15069inline void algo::RspaceStr26::operator =(const algo::strptr &str) {
15070    ch_SetStrptr(*this, str);
15071}
15072
15073// --- algo.RspaceStr26.ch.Set
15074// Copy from same type
15075// Copy value from RHS.
15076inline void algo::RspaceStr26::operator =(const algo::RspaceStr26& parent) {
15077    memcpy(ch, parent.ch, 26);
15078}
15079
15080// --- algo.RspaceStr26.ch.Ctor
15081inline  algo::RspaceStr26::RspaceStr26(const algo::RspaceStr26 &rhs) {
15082    operator =(rhs);
15083}
15084
15085// --- algo.RspaceStr26.ch.CtorStrptr
15086inline  algo::RspaceStr26::RspaceStr26(const algo::strptr &rhs) {
15087    ch_SetStrptr(*this, rhs);
15088}
15089
15090// --- algo.RspaceStr26.ch.Cast
15091inline algo::RspaceStr26::operator algo::strptr () const {
15092    return ch_Getary(*this);
15093}
15094
15095// --- algo.RspaceStr26..Cmp
15096inline i32 algo::RspaceStr26_Cmp(algo::RspaceStr26& lhs, algo::RspaceStr26& rhs) {
15097    i32 retval = 0;
15098    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15099    return retval;
15100}
15101
15102// --- algo.RspaceStr26..Init
15103// Set all fields to initial values.
15104inline void algo::RspaceStr26_Init(algo::RspaceStr26& parent) {
15105    memset(parent.ch, ' ', 26);
15106}
15107
15108// --- algo.RspaceStr26..Eq
15109inline bool algo::RspaceStr26_Eq(algo::RspaceStr26& lhs, algo::RspaceStr26& rhs) {
15110    bool retval = true;
15111    retval = retval
15112    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15113    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15114    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15115    &&*(u16*)(lhs.ch+24) == *(u16*)(rhs.ch+24);
15116    return retval;
15117}
15118
15119// --- algo.RspaceStr26..EqStrptr
15120inline bool algo::RspaceStr26_EqStrptr(const algo::RspaceStr26& lhs, const algo::strptr& rhs) {
15121    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15122}
15123
15124inline bool algo::RspaceStr3::operator ==(const algo::RspaceStr3 &rhs) const {
15125    return algo::RspaceStr3_Eq(const_cast<algo::RspaceStr3&>(*this),const_cast<algo::RspaceStr3&>(rhs));
15126}
15127
15128inline bool algo::RspaceStr3::operator !=(const algo::RspaceStr3 &rhs) const {
15129    return !algo::RspaceStr3_Eq(const_cast<algo::RspaceStr3&>(*this),const_cast<algo::RspaceStr3&>(rhs));
15130}
15131
15132inline bool algo::RspaceStr3::operator ==(const algo::strptr &rhs) const {
15133    return algo::RspaceStr3_EqStrptr(const_cast<algo::RspaceStr3&>(*this),rhs);
15134}
15135inline algo::RspaceStr3::RspaceStr3() {
15136    algo::RspaceStr3_Init(*this);
15137}
15138
15139
15140// --- algo.RspaceStr3.ch.Getary
15141// Access string as array of chars
15142inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr3& parent) {
15143    int len = ch_N(parent);
15144    algo::aryptr<char> ret((char*)parent.ch, len);
15145    return ret;
15146}
15147
15148// --- algo.RspaceStr3.ch.HashStrptr
15149inline u32 algo::RspaceStr3_Hash(u32 prev, const algo::strptr &str) {
15150    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15151}
15152
15153// --- algo.RspaceStr3.ch.Init
15154inline void algo::ch_Init(algo::RspaceStr3 &parent) {
15155    memset(parent.ch, ' ', 3);
15156}
15157
15158// --- algo.RspaceStr3.ch.Max
15159// always return constant 3
15160inline int algo::ch_Max(algo::RspaceStr3& parent) {
15161    (void)parent;
15162    return 3;
15163}
15164
15165// --- algo.RspaceStr3.ch.N
15166inline int algo::ch_N(const algo::RspaceStr3& parent) {
15167    u64 ret;
15168    ret = 3;
15169    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15170        ret--;
15171    }
15172    return int(ret);
15173}
15174
15175// --- algo.RspaceStr3.ch.AssignStrptr
15176// Copy from strptr (operator=)
15177inline void algo::RspaceStr3::operator =(const algo::strptr &str) {
15178    ch_SetStrptr(*this, str);
15179}
15180
15181// --- algo.RspaceStr3.ch.Set
15182// Copy from same type
15183// Copy value from RHS.
15184inline void algo::RspaceStr3::operator =(const algo::RspaceStr3& parent) {
15185    memcpy(ch, parent.ch, 3);
15186}
15187
15188// --- algo.RspaceStr3.ch.Ctor
15189inline  algo::RspaceStr3::RspaceStr3(const algo::RspaceStr3 &rhs) {
15190    operator =(rhs);
15191}
15192
15193// --- algo.RspaceStr3.ch.CtorStrptr
15194inline  algo::RspaceStr3::RspaceStr3(const algo::strptr &rhs) {
15195    ch_SetStrptr(*this, rhs);
15196}
15197
15198// --- algo.RspaceStr3.ch.Cast
15199inline algo::RspaceStr3::operator algo::strptr () const {
15200    return ch_Getary(*this);
15201}
15202
15203// --- algo.RspaceStr3..Cmp
15204inline i32 algo::RspaceStr3_Cmp(algo::RspaceStr3 lhs, algo::RspaceStr3 rhs) {
15205    i32 retval = 0;
15206    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15207    return retval;
15208}
15209
15210// --- algo.RspaceStr3..Init
15211// Set all fields to initial values.
15212inline void algo::RspaceStr3_Init(algo::RspaceStr3& parent) {
15213    memset(parent.ch, ' ', 3);
15214}
15215
15216// --- algo.RspaceStr3..Eq
15217inline bool algo::RspaceStr3_Eq(algo::RspaceStr3 lhs, algo::RspaceStr3 rhs) {
15218    bool retval = true;
15219    retval = retval
15220    &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
15221    &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
15222    return retval;
15223}
15224
15225// --- algo.RspaceStr3..EqStrptr
15226inline bool algo::RspaceStr3_EqStrptr(algo::RspaceStr3 lhs, const algo::strptr& rhs) {
15227    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15228}
15229
15230inline bool algo::RspaceStr31::operator ==(const algo::RspaceStr31 &rhs) const {
15231    return algo::RspaceStr31_Eq(const_cast<algo::RspaceStr31&>(*this),const_cast<algo::RspaceStr31&>(rhs));
15232}
15233
15234inline bool algo::RspaceStr31::operator !=(const algo::RspaceStr31 &rhs) const {
15235    return !algo::RspaceStr31_Eq(const_cast<algo::RspaceStr31&>(*this),const_cast<algo::RspaceStr31&>(rhs));
15236}
15237
15238inline bool algo::RspaceStr31::operator ==(const algo::strptr &rhs) const {
15239    return algo::RspaceStr31_EqStrptr(const_cast<algo::RspaceStr31&>(*this),rhs);
15240}
15241inline algo::RspaceStr31::RspaceStr31() {
15242    algo::RspaceStr31_Init(*this);
15243}
15244
15245
15246// --- algo.RspaceStr31.ch.Getary
15247// Access string as array of chars
15248inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr31& parent) {
15249    int len = ch_N(parent);
15250    algo::aryptr<char> ret((char*)parent.ch, len);
15251    return ret;
15252}
15253
15254// --- algo.RspaceStr31.ch.HashStrptr
15255inline u32 algo::RspaceStr31_Hash(u32 prev, const algo::strptr &str) {
15256    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15257}
15258
15259// --- algo.RspaceStr31.ch.Init
15260inline void algo::ch_Init(algo::RspaceStr31 &parent) {
15261    memset(parent.ch, ' ', 31);
15262}
15263
15264// --- algo.RspaceStr31.ch.Max
15265// always return constant 31
15266inline int algo::ch_Max(algo::RspaceStr31& parent) {
15267    (void)parent;
15268    return 31;
15269}
15270
15271// --- algo.RspaceStr31.ch.N
15272inline int algo::ch_N(const algo::RspaceStr31& parent) {
15273    u64 ret;
15274    ret = 31;
15275    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15276        ret--;
15277    }
15278    return int(ret);
15279}
15280
15281// --- algo.RspaceStr31.ch.AssignStrptr
15282// Copy from strptr (operator=)
15283inline void algo::RspaceStr31::operator =(const algo::strptr &str) {
15284    ch_SetStrptr(*this, str);
15285}
15286
15287// --- algo.RspaceStr31.ch.Set
15288// Copy from same type
15289// Copy value from RHS.
15290inline void algo::RspaceStr31::operator =(const algo::RspaceStr31& parent) {
15291    memcpy(ch, parent.ch, 31);
15292}
15293
15294// --- algo.RspaceStr31.ch.Ctor
15295inline  algo::RspaceStr31::RspaceStr31(const algo::RspaceStr31 &rhs) {
15296    operator =(rhs);
15297}
15298
15299// --- algo.RspaceStr31.ch.CtorStrptr
15300inline  algo::RspaceStr31::RspaceStr31(const algo::strptr &rhs) {
15301    ch_SetStrptr(*this, rhs);
15302}
15303
15304// --- algo.RspaceStr31.ch.Cast
15305inline algo::RspaceStr31::operator algo::strptr () const {
15306    return ch_Getary(*this);
15307}
15308
15309// --- algo.RspaceStr31..Cmp
15310inline i32 algo::RspaceStr31_Cmp(algo::RspaceStr31& lhs, algo::RspaceStr31& rhs) {
15311    i32 retval = 0;
15312    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15313    return retval;
15314}
15315
15316// --- algo.RspaceStr31..Init
15317// Set all fields to initial values.
15318inline void algo::RspaceStr31_Init(algo::RspaceStr31& parent) {
15319    memset(parent.ch, ' ', 31);
15320}
15321
15322// --- algo.RspaceStr31..Eq
15323inline bool algo::RspaceStr31_Eq(algo::RspaceStr31& lhs, algo::RspaceStr31& rhs) {
15324    bool retval = true;
15325    retval = retval
15326    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15327    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15328    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15329    &&*(u32*)(lhs.ch+24) == *(u32*)(rhs.ch+24)
15330    &&*(u16*)(lhs.ch+28) == *(u16*)(rhs.ch+28)
15331    &&*(u8*)(lhs.ch+30) == *(u8*)(rhs.ch+30);
15332    return retval;
15333}
15334
15335// --- algo.RspaceStr31..EqStrptr
15336inline bool algo::RspaceStr31_EqStrptr(const algo::RspaceStr31& lhs, const algo::strptr& rhs) {
15337    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15338}
15339
15340inline bool algo::RspaceStr32::operator ==(const algo::RspaceStr32 &rhs) const {
15341    return algo::RspaceStr32_Eq(const_cast<algo::RspaceStr32&>(*this),const_cast<algo::RspaceStr32&>(rhs));
15342}
15343
15344inline bool algo::RspaceStr32::operator !=(const algo::RspaceStr32 &rhs) const {
15345    return !algo::RspaceStr32_Eq(const_cast<algo::RspaceStr32&>(*this),const_cast<algo::RspaceStr32&>(rhs));
15346}
15347
15348inline bool algo::RspaceStr32::operator ==(const algo::strptr &rhs) const {
15349    return algo::RspaceStr32_EqStrptr(const_cast<algo::RspaceStr32&>(*this),rhs);
15350}
15351inline algo::RspaceStr32::RspaceStr32() {
15352    algo::RspaceStr32_Init(*this);
15353}
15354
15355
15356// --- algo.RspaceStr32.ch.Getary
15357// Access string as array of chars
15358inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr32& parent) {
15359    int len = ch_N(parent);
15360    algo::aryptr<char> ret((char*)parent.ch, len);
15361    return ret;
15362}
15363
15364// --- algo.RspaceStr32.ch.HashStrptr
15365inline u32 algo::RspaceStr32_Hash(u32 prev, const algo::strptr &str) {
15366    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15367}
15368
15369// --- algo.RspaceStr32.ch.Init
15370inline void algo::ch_Init(algo::RspaceStr32 &parent) {
15371    memset(parent.ch, ' ', 32);
15372}
15373
15374// --- algo.RspaceStr32.ch.Max
15375// always return constant 32
15376inline int algo::ch_Max(algo::RspaceStr32& parent) {
15377    (void)parent;
15378    return 32;
15379}
15380
15381// --- algo.RspaceStr32.ch.N
15382inline int algo::ch_N(const algo::RspaceStr32& parent) {
15383    u64 ret;
15384    ret = 32;
15385    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15386        ret--;
15387    }
15388    return int(ret);
15389}
15390
15391// --- algo.RspaceStr32.ch.AssignStrptr
15392// Copy from strptr (operator=)
15393inline void algo::RspaceStr32::operator =(const algo::strptr &str) {
15394    ch_SetStrptr(*this, str);
15395}
15396
15397// --- algo.RspaceStr32.ch.Set
15398// Copy from same type
15399// Copy value from RHS.
15400inline void algo::RspaceStr32::operator =(const algo::RspaceStr32& parent) {
15401    memcpy(ch, parent.ch, 32);
15402}
15403
15404// --- algo.RspaceStr32.ch.Ctor
15405inline  algo::RspaceStr32::RspaceStr32(const algo::RspaceStr32 &rhs) {
15406    operator =(rhs);
15407}
15408
15409// --- algo.RspaceStr32.ch.CtorStrptr
15410inline  algo::RspaceStr32::RspaceStr32(const algo::strptr &rhs) {
15411    ch_SetStrptr(*this, rhs);
15412}
15413
15414// --- algo.RspaceStr32.ch.Cast
15415inline algo::RspaceStr32::operator algo::strptr () const {
15416    return ch_Getary(*this);
15417}
15418
15419// --- algo.RspaceStr32..Cmp
15420inline i32 algo::RspaceStr32_Cmp(algo::RspaceStr32 lhs, algo::RspaceStr32 rhs) {
15421    i32 retval = 0;
15422    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15423    return retval;
15424}
15425
15426// --- algo.RspaceStr32..Init
15427// Set all fields to initial values.
15428inline void algo::RspaceStr32_Init(algo::RspaceStr32& parent) {
15429    memset(parent.ch, ' ', 32);
15430}
15431
15432// --- algo.RspaceStr32..Eq
15433inline bool algo::RspaceStr32_Eq(algo::RspaceStr32 lhs, algo::RspaceStr32 rhs) {
15434    bool retval = true;
15435    retval = retval
15436    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15437    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15438    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15439    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24);
15440    return retval;
15441}
15442
15443// --- algo.RspaceStr32..EqStrptr
15444inline bool algo::RspaceStr32_EqStrptr(algo::RspaceStr32 lhs, const algo::strptr& rhs) {
15445    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15446}
15447
15448inline bool algo::RspaceStr4::operator ==(const algo::RspaceStr4 &rhs) const {
15449    return algo::RspaceStr4_Eq(const_cast<algo::RspaceStr4&>(*this),const_cast<algo::RspaceStr4&>(rhs));
15450}
15451
15452inline bool algo::RspaceStr4::operator !=(const algo::RspaceStr4 &rhs) const {
15453    return !algo::RspaceStr4_Eq(const_cast<algo::RspaceStr4&>(*this),const_cast<algo::RspaceStr4&>(rhs));
15454}
15455
15456inline bool algo::RspaceStr4::operator ==(const algo::strptr &rhs) const {
15457    return algo::RspaceStr4_EqStrptr(const_cast<algo::RspaceStr4&>(*this),rhs);
15458}
15459inline algo::RspaceStr4::RspaceStr4() {
15460    algo::RspaceStr4_Init(*this);
15461}
15462
15463
15464// --- algo.RspaceStr4.ch.Getary
15465// Access string as array of chars
15466inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr4& parent) {
15467    int len = ch_N(parent);
15468    algo::aryptr<char> ret((char*)parent.ch, len);
15469    return ret;
15470}
15471
15472// --- algo.RspaceStr4.ch.HashStrptr
15473inline u32 algo::RspaceStr4_Hash(u32 prev, const algo::strptr &str) {
15474    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15475}
15476
15477// --- algo.RspaceStr4.ch.Init
15478inline void algo::ch_Init(algo::RspaceStr4 &parent) {
15479    memset(parent.ch, ' ', 4);
15480}
15481
15482// --- algo.RspaceStr4.ch.Max
15483// always return constant 4
15484inline int algo::ch_Max(algo::RspaceStr4& parent) {
15485    (void)parent;
15486    return 4;
15487}
15488
15489// --- algo.RspaceStr4.ch.N
15490inline int algo::ch_N(const algo::RspaceStr4& parent) {
15491    u64 ret;
15492    ret = 4;
15493    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15494        ret--;
15495    }
15496    return int(ret);
15497}
15498
15499// --- algo.RspaceStr4.ch.AssignStrptr
15500// Copy from strptr (operator=)
15501inline void algo::RspaceStr4::operator =(const algo::strptr &str) {
15502    ch_SetStrptr(*this, str);
15503}
15504
15505// --- algo.RspaceStr4.ch.Set
15506// Copy from same type
15507// Copy value from RHS.
15508inline void algo::RspaceStr4::operator =(const algo::RspaceStr4& parent) {
15509    memcpy(ch, parent.ch, 4);
15510}
15511
15512// --- algo.RspaceStr4.ch.Ctor
15513inline  algo::RspaceStr4::RspaceStr4(const algo::RspaceStr4 &rhs) {
15514    operator =(rhs);
15515}
15516
15517// --- algo.RspaceStr4.ch.CtorStrptr
15518inline  algo::RspaceStr4::RspaceStr4(const algo::strptr &rhs) {
15519    ch_SetStrptr(*this, rhs);
15520}
15521
15522// --- algo.RspaceStr4.ch.Cast
15523inline algo::RspaceStr4::operator algo::strptr () const {
15524    return ch_Getary(*this);
15525}
15526
15527// --- algo.RspaceStr4..Cmp
15528inline i32 algo::RspaceStr4_Cmp(algo::RspaceStr4 lhs, algo::RspaceStr4 rhs) {
15529    i32 retval = 0;
15530    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15531    return retval;
15532}
15533
15534// --- algo.RspaceStr4..Init
15535// Set all fields to initial values.
15536inline void algo::RspaceStr4_Init(algo::RspaceStr4& parent) {
15537    memset(parent.ch, ' ', 4);
15538}
15539
15540// --- algo.RspaceStr4..Eq
15541inline bool algo::RspaceStr4_Eq(algo::RspaceStr4 lhs, algo::RspaceStr4 rhs) {
15542    bool retval = true;
15543    retval = retval
15544    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
15545    return retval;
15546}
15547
15548// --- algo.RspaceStr4..EqStrptr
15549inline bool algo::RspaceStr4_EqStrptr(algo::RspaceStr4 lhs, const algo::strptr& rhs) {
15550    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15551}
15552inline algo::RspaceStr40::RspaceStr40() {
15553    algo::RspaceStr40_Init(*this);
15554}
15555
15556
15557// --- algo.RspaceStr40.ch.Getary
15558// Access string as array of chars
15559inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr40& parent) {
15560    int len = ch_N(parent);
15561    algo::aryptr<char> ret((char*)parent.ch, len);
15562    return ret;
15563}
15564
15565// --- algo.RspaceStr40.ch.HashStrptr
15566inline u32 algo::RspaceStr40_Hash(u32 prev, const algo::strptr &str) {
15567    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15568}
15569
15570// --- algo.RspaceStr40.ch.Init
15571inline void algo::ch_Init(algo::RspaceStr40 &parent) {
15572    memset(parent.ch, ' ', 40);
15573}
15574
15575// --- algo.RspaceStr40.ch.Max
15576// always return constant 40
15577inline int algo::ch_Max(algo::RspaceStr40& parent) {
15578    (void)parent;
15579    return 40;
15580}
15581
15582// --- algo.RspaceStr40.ch.N
15583inline int algo::ch_N(const algo::RspaceStr40& parent) {
15584    u64 ret;
15585    ret = 40;
15586    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15587        ret--;
15588    }
15589    return int(ret);
15590}
15591
15592// --- algo.RspaceStr40.ch.AssignStrptr
15593// Copy from strptr (operator=)
15594inline void algo::RspaceStr40::operator =(const algo::strptr &str) {
15595    ch_SetStrptr(*this, str);
15596}
15597
15598// --- algo.RspaceStr40.ch.Set
15599// Copy from same type
15600// Copy value from RHS.
15601inline void algo::RspaceStr40::operator =(const algo::RspaceStr40& parent) {
15602    memcpy(ch, parent.ch, 40);
15603}
15604
15605// --- algo.RspaceStr40.ch.Ctor
15606inline  algo::RspaceStr40::RspaceStr40(const algo::RspaceStr40 &rhs) {
15607    operator =(rhs);
15608}
15609
15610// --- algo.RspaceStr40.ch.CtorStrptr
15611inline  algo::RspaceStr40::RspaceStr40(const algo::strptr &rhs) {
15612    ch_SetStrptr(*this, rhs);
15613}
15614
15615// --- algo.RspaceStr40.ch.Cast
15616inline algo::RspaceStr40::operator algo::strptr () const {
15617    return ch_Getary(*this);
15618}
15619
15620// --- algo.RspaceStr40..Cmp
15621inline i32 algo::RspaceStr40_Cmp(algo::RspaceStr40 lhs, algo::RspaceStr40 rhs) {
15622    i32 retval = 0;
15623    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15624    return retval;
15625}
15626
15627// --- algo.RspaceStr40..Init
15628// Set all fields to initial values.
15629inline void algo::RspaceStr40_Init(algo::RspaceStr40& parent) {
15630    memset(parent.ch, ' ', 40);
15631}
15632
15633// --- algo.RspaceStr40..Eq
15634inline bool algo::RspaceStr40_Eq(algo::RspaceStr40 lhs, algo::RspaceStr40 rhs) {
15635    bool retval = true;
15636    retval = retval
15637    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15638    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15639    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15640    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
15641    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32);
15642    return retval;
15643}
15644
15645// --- algo.RspaceStr40..EqStrptr
15646inline bool algo::RspaceStr40_EqStrptr(algo::RspaceStr40 lhs, const algo::strptr& rhs) {
15647    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15648}
15649
15650inline bool algo::RspaceStr5::operator ==(const algo::RspaceStr5 &rhs) const {
15651    return algo::RspaceStr5_Eq(const_cast<algo::RspaceStr5&>(*this),const_cast<algo::RspaceStr5&>(rhs));
15652}
15653
15654inline bool algo::RspaceStr5::operator !=(const algo::RspaceStr5 &rhs) const {
15655    return !algo::RspaceStr5_Eq(const_cast<algo::RspaceStr5&>(*this),const_cast<algo::RspaceStr5&>(rhs));
15656}
15657
15658inline bool algo::RspaceStr5::operator ==(const algo::strptr &rhs) const {
15659    return algo::RspaceStr5_EqStrptr(const_cast<algo::RspaceStr5&>(*this),rhs);
15660}
15661inline algo::RspaceStr5::RspaceStr5() {
15662    algo::RspaceStr5_Init(*this);
15663}
15664
15665
15666// --- algo.RspaceStr5.ch.Getary
15667// Access string as array of chars
15668inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr5& parent) {
15669    int len = ch_N(parent);
15670    algo::aryptr<char> ret((char*)parent.ch, len);
15671    return ret;
15672}
15673
15674// --- algo.RspaceStr5.ch.HashStrptr
15675inline u32 algo::RspaceStr5_Hash(u32 prev, const algo::strptr &str) {
15676    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15677}
15678
15679// --- algo.RspaceStr5.ch.Init
15680inline void algo::ch_Init(algo::RspaceStr5 &parent) {
15681    memset(parent.ch, ' ', 5);
15682}
15683
15684// --- algo.RspaceStr5.ch.Max
15685// always return constant 5
15686inline int algo::ch_Max(algo::RspaceStr5& parent) {
15687    (void)parent;
15688    return 5;
15689}
15690
15691// --- algo.RspaceStr5.ch.N
15692inline int algo::ch_N(const algo::RspaceStr5& parent) {
15693    u64 ret;
15694    ret = 5;
15695    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15696        ret--;
15697    }
15698    return int(ret);
15699}
15700
15701// --- algo.RspaceStr5.ch.AssignStrptr
15702// Copy from strptr (operator=)
15703inline void algo::RspaceStr5::operator =(const algo::strptr &str) {
15704    ch_SetStrptr(*this, str);
15705}
15706
15707// --- algo.RspaceStr5.ch.Set
15708// Copy from same type
15709// Copy value from RHS.
15710inline void algo::RspaceStr5::operator =(const algo::RspaceStr5& parent) {
15711    memcpy(ch, parent.ch, 5);
15712}
15713
15714// --- algo.RspaceStr5.ch.Ctor
15715inline  algo::RspaceStr5::RspaceStr5(const algo::RspaceStr5 &rhs) {
15716    operator =(rhs);
15717}
15718
15719// --- algo.RspaceStr5.ch.CtorStrptr
15720inline  algo::RspaceStr5::RspaceStr5(const algo::strptr &rhs) {
15721    ch_SetStrptr(*this, rhs);
15722}
15723
15724// --- algo.RspaceStr5.ch.Cast
15725inline algo::RspaceStr5::operator algo::strptr () const {
15726    return ch_Getary(*this);
15727}
15728
15729// --- algo.RspaceStr5..Cmp
15730inline i32 algo::RspaceStr5_Cmp(algo::RspaceStr5 lhs, algo::RspaceStr5 rhs) {
15731    i32 retval = 0;
15732    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15733    return retval;
15734}
15735
15736// --- algo.RspaceStr5..Init
15737// Set all fields to initial values.
15738inline void algo::RspaceStr5_Init(algo::RspaceStr5& parent) {
15739    memset(parent.ch, ' ', 5);
15740}
15741
15742// --- algo.RspaceStr5..Eq
15743inline bool algo::RspaceStr5_Eq(algo::RspaceStr5 lhs, algo::RspaceStr5 rhs) {
15744    bool retval = true;
15745    retval = retval
15746    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
15747    &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
15748    return retval;
15749}
15750
15751// --- algo.RspaceStr5..EqStrptr
15752inline bool algo::RspaceStr5_EqStrptr(algo::RspaceStr5 lhs, const algo::strptr& rhs) {
15753    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15754}
15755
15756inline bool algo::RspaceStr50::operator ==(const algo::RspaceStr50 &rhs) const {
15757    return algo::RspaceStr50_Eq(const_cast<algo::RspaceStr50&>(*this),const_cast<algo::RspaceStr50&>(rhs));
15758}
15759
15760inline bool algo::RspaceStr50::operator !=(const algo::RspaceStr50 &rhs) const {
15761    return !algo::RspaceStr50_Eq(const_cast<algo::RspaceStr50&>(*this),const_cast<algo::RspaceStr50&>(rhs));
15762}
15763
15764inline bool algo::RspaceStr50::operator ==(const algo::strptr &rhs) const {
15765    return algo::RspaceStr50_EqStrptr(const_cast<algo::RspaceStr50&>(*this),rhs);
15766}
15767inline algo::RspaceStr50::RspaceStr50() {
15768    algo::RspaceStr50_Init(*this);
15769}
15770
15771
15772// --- algo.RspaceStr50.ch.Getary
15773// Access string as array of chars
15774inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr50& parent) {
15775    int len = ch_N(parent);
15776    algo::aryptr<char> ret((char*)parent.ch, len);
15777    return ret;
15778}
15779
15780// --- algo.RspaceStr50.ch.HashStrptr
15781inline u32 algo::RspaceStr50_Hash(u32 prev, const algo::strptr &str) {
15782    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15783}
15784
15785// --- algo.RspaceStr50.ch.Init
15786inline void algo::ch_Init(algo::RspaceStr50 &parent) {
15787    memset(parent.ch, ' ', 50);
15788}
15789
15790// --- algo.RspaceStr50.ch.Max
15791// always return constant 50
15792inline int algo::ch_Max(algo::RspaceStr50& parent) {
15793    (void)parent;
15794    return 50;
15795}
15796
15797// --- algo.RspaceStr50.ch.N
15798inline int algo::ch_N(const algo::RspaceStr50& parent) {
15799    u64 ret;
15800    ret = 50;
15801    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15802        ret--;
15803    }
15804    return int(ret);
15805}
15806
15807// --- algo.RspaceStr50.ch.AssignStrptr
15808// Copy from strptr (operator=)
15809inline void algo::RspaceStr50::operator =(const algo::strptr &str) {
15810    ch_SetStrptr(*this, str);
15811}
15812
15813// --- algo.RspaceStr50.ch.Set
15814// Copy from same type
15815// Copy value from RHS.
15816inline void algo::RspaceStr50::operator =(const algo::RspaceStr50& parent) {
15817    memcpy(ch, parent.ch, 50);
15818}
15819
15820// --- algo.RspaceStr50.ch.Ctor
15821inline  algo::RspaceStr50::RspaceStr50(const algo::RspaceStr50 &rhs) {
15822    operator =(rhs);
15823}
15824
15825// --- algo.RspaceStr50.ch.CtorStrptr
15826inline  algo::RspaceStr50::RspaceStr50(const algo::strptr &rhs) {
15827    ch_SetStrptr(*this, rhs);
15828}
15829
15830// --- algo.RspaceStr50.ch.Cast
15831inline algo::RspaceStr50::operator algo::strptr () const {
15832    return ch_Getary(*this);
15833}
15834
15835// --- algo.RspaceStr50..Cmp
15836inline i32 algo::RspaceStr50_Cmp(algo::RspaceStr50 lhs, algo::RspaceStr50 rhs) {
15837    i32 retval = 0;
15838    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15839    return retval;
15840}
15841
15842// --- algo.RspaceStr50..Init
15843// Set all fields to initial values.
15844inline void algo::RspaceStr50_Init(algo::RspaceStr50& parent) {
15845    memset(parent.ch, ' ', 50);
15846}
15847
15848// --- algo.RspaceStr50..Eq
15849inline bool algo::RspaceStr50_Eq(algo::RspaceStr50 lhs, algo::RspaceStr50 rhs) {
15850    bool retval = true;
15851    retval = retval
15852    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15853    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15854    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15855    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
15856    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
15857    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
15858    &&*(u16*)(lhs.ch+48) == *(u16*)(rhs.ch+48);
15859    return retval;
15860}
15861
15862// --- algo.RspaceStr50..EqStrptr
15863inline bool algo::RspaceStr50_EqStrptr(algo::RspaceStr50 lhs, const algo::strptr& rhs) {
15864    return algo::strptr_Eq(ch_Getary(lhs), rhs);
15865}
15866
15867inline bool algo::RspaceStr6::operator ==(const algo::RspaceStr6 &rhs) const {
15868    return algo::RspaceStr6_Eq(const_cast<algo::RspaceStr6&>(*this),const_cast<algo::RspaceStr6&>(rhs));
15869}
15870
15871inline bool algo::RspaceStr6::operator !=(const algo::RspaceStr6 &rhs) const {
15872    return !algo::RspaceStr6_Eq(const_cast<algo::RspaceStr6&>(*this),const_cast<algo::RspaceStr6&>(rhs));
15873}
15874
15875inline bool algo::RspaceStr6::operator ==(const algo::strptr &rhs) const {
15876    return algo::RspaceStr6_EqStrptr(const_cast<algo::RspaceStr6&>(*this),rhs);
15877}
15878
15879inline bool algo::RspaceStr6::operator <(const algo::RspaceStr6 &rhs) const {
15880    return algo::RspaceStr6_Lt(const_cast<algo::RspaceStr6&>(*this),const_cast<algo::RspaceStr6&>(rhs));
15881}
15882
15883inline bool algo::RspaceStr6::operator >(const algo::RspaceStr6 &rhs) const {
15884    return rhs < *this;
15885}
15886
15887inline bool algo::RspaceStr6::operator <=(const algo::RspaceStr6 &rhs) const {
15888    return !(rhs < *this);
15889}
15890
15891inline bool algo::RspaceStr6::operator >=(const algo::RspaceStr6 &rhs) const {
15892    return !(*this < rhs);
15893}
15894inline algo::RspaceStr6::RspaceStr6() {
15895    algo::RspaceStr6_Init(*this);
15896}
15897
15898
15899// --- algo.RspaceStr6.ch.Getary
15900// Access string as array of chars
15901inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr6& parent) {
15902    int len = ch_N(parent);
15903    algo::aryptr<char> ret((char*)parent.ch, len);
15904    return ret;
15905}
15906
15907// --- algo.RspaceStr6.ch.HashStrptr
15908inline u32 algo::RspaceStr6_Hash(u32 prev, const algo::strptr &str) {
15909    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15910}
15911
15912// --- algo.RspaceStr6.ch.Init
15913inline void algo::ch_Init(algo::RspaceStr6 &parent) {
15914    memset(parent.ch, ' ', 6);
15915}
15916
15917// --- algo.RspaceStr6.ch.Max
15918// always return constant 6
15919inline int algo::ch_Max(algo::RspaceStr6& parent) {
15920    (void)parent;
15921    return 6;
15922}
15923
15924// --- algo.RspaceStr6.ch.N
15925inline int algo::ch_N(const algo::RspaceStr6& parent) {
15926    u64 ret;
15927    ret = 6;
15928    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15929        ret--;
15930    }
15931    return int(ret);
15932}
15933
15934// --- algo.RspaceStr6.ch.AssignStrptr
15935// Copy from strptr (operator=)
15936inline void algo::RspaceStr6::operator =(const algo::strptr &str) {
15937    ch_SetStrptr(*this, str);
15938}
15939
15940// --- algo.RspaceStr6.ch.Set
15941// Copy from same type
15942// Copy value from RHS.
15943inline void algo::RspaceStr6::operator =(const algo::RspaceStr6& parent) {
15944    memcpy(ch, parent.ch, 6);
15945}
15946
15947// --- algo.RspaceStr6.ch.Ctor
15948inline  algo::RspaceStr6::RspaceStr6(const algo::RspaceStr6 &rhs) {
15949    operator =(rhs);
15950}
15951
15952// --- algo.RspaceStr6.ch.CtorStrptr
15953inline  algo::RspaceStr6::RspaceStr6(const algo::strptr &rhs) {
15954    ch_SetStrptr(*this, rhs);
15955}
15956
15957// --- algo.RspaceStr6.ch.Cast
15958inline algo::RspaceStr6::operator algo::strptr () const {
15959    return ch_Getary(*this);
15960}
15961
15962// --- algo.RspaceStr6..Lt
15963inline bool algo::RspaceStr6_Lt(algo::RspaceStr6 lhs, algo::RspaceStr6 rhs) {
15964    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
15965}
15966
15967// --- algo.RspaceStr6..Cmp
15968inline i32 algo::RspaceStr6_Cmp(algo::RspaceStr6 lhs, algo::RspaceStr6 rhs) {
15969    i32 retval = 0;
15970    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15971    return retval;
15972}
15973
15974// --- algo.RspaceStr6..Init
15975// Set all fields to initial values.
15976inline void algo::RspaceStr6_Init(algo::RspaceStr6& parent) {
15977    memset(parent.ch, ' ', 6);
15978}
15979
15980// --- algo.RspaceStr6..Eq
15981inline bool algo::RspaceStr6_Eq(algo::RspaceStr6 lhs, algo::RspaceStr6 rhs) {
15982    bool retval = true;
15983    retval = retval
15984    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
15985    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
15986    return retval;
15987}
15988
15989// --- algo.RspaceStr6..Update
15990// Set value. Return true if new value is different from old value.
15991inline bool algo::RspaceStr6_Update(algo::RspaceStr6 &lhs, algo::RspaceStr6 rhs) {
15992    bool ret = !RspaceStr6_Eq(lhs, rhs); // compare values
15993    if (ret) {
15994        lhs = rhs; // update
15995    }
15996    return ret;
15997}
15998
15999// --- algo.RspaceStr6..EqStrptr
16000inline bool algo::RspaceStr6_EqStrptr(algo::RspaceStr6 lhs, const algo::strptr& rhs) {
16001    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16002}
16003
16004inline bool algo::RspaceStr64::operator ==(const algo::RspaceStr64 &rhs) const {
16005    return algo::RspaceStr64_Eq(const_cast<algo::RspaceStr64&>(*this),const_cast<algo::RspaceStr64&>(rhs));
16006}
16007
16008inline bool algo::RspaceStr64::operator !=(const algo::RspaceStr64 &rhs) const {
16009    return !algo::RspaceStr64_Eq(const_cast<algo::RspaceStr64&>(*this),const_cast<algo::RspaceStr64&>(rhs));
16010}
16011
16012inline bool algo::RspaceStr64::operator ==(const algo::strptr &rhs) const {
16013    return algo::RspaceStr64_EqStrptr(const_cast<algo::RspaceStr64&>(*this),rhs);
16014}
16015inline algo::RspaceStr64::RspaceStr64() {
16016    algo::RspaceStr64_Init(*this);
16017}
16018
16019
16020// --- algo.RspaceStr64.ch.Getary
16021// Access string as array of chars
16022inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr64& parent) {
16023    int len = ch_N(parent);
16024    algo::aryptr<char> ret((char*)parent.ch, len);
16025    return ret;
16026}
16027
16028// --- algo.RspaceStr64.ch.HashStrptr
16029inline u32 algo::RspaceStr64_Hash(u32 prev, const algo::strptr &str) {
16030    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16031}
16032
16033// --- algo.RspaceStr64.ch.Init
16034inline void algo::ch_Init(algo::RspaceStr64 &parent) {
16035    memset(parent.ch, ' ', 64);
16036}
16037
16038// --- algo.RspaceStr64.ch.Max
16039// always return constant 64
16040inline int algo::ch_Max(algo::RspaceStr64& parent) {
16041    (void)parent;
16042    return 64;
16043}
16044
16045// --- algo.RspaceStr64.ch.N
16046inline int algo::ch_N(const algo::RspaceStr64& parent) {
16047    u64 ret;
16048    ret = 64;
16049    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16050        ret--;
16051    }
16052    return int(ret);
16053}
16054
16055// --- algo.RspaceStr64.ch.AssignStrptr
16056// Copy from strptr (operator=)
16057inline void algo::RspaceStr64::operator =(const algo::strptr &str) {
16058    ch_SetStrptr(*this, str);
16059}
16060
16061// --- algo.RspaceStr64.ch.Set
16062// Copy from same type
16063// Copy value from RHS.
16064inline void algo::RspaceStr64::operator =(const algo::RspaceStr64& parent) {
16065    memcpy(ch, parent.ch, 64);
16066}
16067
16068// --- algo.RspaceStr64.ch.Ctor
16069inline  algo::RspaceStr64::RspaceStr64(const algo::RspaceStr64 &rhs) {
16070    operator =(rhs);
16071}
16072
16073// --- algo.RspaceStr64.ch.CtorStrptr
16074inline  algo::RspaceStr64::RspaceStr64(const algo::strptr &rhs) {
16075    ch_SetStrptr(*this, rhs);
16076}
16077
16078// --- algo.RspaceStr64.ch.Cast
16079inline algo::RspaceStr64::operator algo::strptr () const {
16080    return ch_Getary(*this);
16081}
16082
16083// --- algo.RspaceStr64..Cmp
16084inline i32 algo::RspaceStr64_Cmp(algo::RspaceStr64& lhs, algo::RspaceStr64& rhs) {
16085    i32 retval = 0;
16086    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16087    return retval;
16088}
16089
16090// --- algo.RspaceStr64..Init
16091// Set all fields to initial values.
16092inline void algo::RspaceStr64_Init(algo::RspaceStr64& parent) {
16093    memset(parent.ch, ' ', 64);
16094}
16095
16096// --- algo.RspaceStr64..Eq
16097inline bool algo::RspaceStr64_Eq(algo::RspaceStr64& lhs, algo::RspaceStr64& rhs) {
16098    bool retval = true;
16099    retval = retval
16100    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
16101    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
16102    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
16103    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
16104    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
16105    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
16106    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
16107    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56);
16108    return retval;
16109}
16110
16111// --- algo.RspaceStr64..EqStrptr
16112inline bool algo::RspaceStr64_EqStrptr(const algo::RspaceStr64& lhs, const algo::strptr& rhs) {
16113    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16114}
16115
16116inline bool algo::RspaceStr7::operator ==(const algo::RspaceStr7 &rhs) const {
16117    return algo::RspaceStr7_Eq(const_cast<algo::RspaceStr7&>(*this),const_cast<algo::RspaceStr7&>(rhs));
16118}
16119
16120inline bool algo::RspaceStr7::operator !=(const algo::RspaceStr7 &rhs) const {
16121    return !algo::RspaceStr7_Eq(const_cast<algo::RspaceStr7&>(*this),const_cast<algo::RspaceStr7&>(rhs));
16122}
16123
16124inline bool algo::RspaceStr7::operator ==(const algo::strptr &rhs) const {
16125    return algo::RspaceStr7_EqStrptr(const_cast<algo::RspaceStr7&>(*this),rhs);
16126}
16127inline algo::RspaceStr7::RspaceStr7() {
16128    algo::RspaceStr7_Init(*this);
16129}
16130
16131
16132// --- algo.RspaceStr7.ch.Getary
16133// Access string as array of chars
16134inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr7& parent) {
16135    int len = ch_N(parent);
16136    algo::aryptr<char> ret((char*)parent.ch, len);
16137    return ret;
16138}
16139
16140// --- algo.RspaceStr7.ch.HashStrptr
16141inline u32 algo::RspaceStr7_Hash(u32 prev, const algo::strptr &str) {
16142    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16143}
16144
16145// --- algo.RspaceStr7.ch.Init
16146inline void algo::ch_Init(algo::RspaceStr7 &parent) {
16147    memset(parent.ch, ' ', 7);
16148}
16149
16150// --- algo.RspaceStr7.ch.Max
16151// always return constant 7
16152inline int algo::ch_Max(algo::RspaceStr7& parent) {
16153    (void)parent;
16154    return 7;
16155}
16156
16157// --- algo.RspaceStr7.ch.N
16158inline int algo::ch_N(const algo::RspaceStr7& parent) {
16159    u64 ret;
16160    ret = 7;
16161    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16162        ret--;
16163    }
16164    return int(ret);
16165}
16166
16167// --- algo.RspaceStr7.ch.AssignStrptr
16168// Copy from strptr (operator=)
16169inline void algo::RspaceStr7::operator =(const algo::strptr &str) {
16170    ch_SetStrptr(*this, str);
16171}
16172
16173// --- algo.RspaceStr7.ch.Set
16174// Copy from same type
16175// Copy value from RHS.
16176inline void algo::RspaceStr7::operator =(const algo::RspaceStr7& parent) {
16177    memcpy(ch, parent.ch, 7);
16178}
16179
16180// --- algo.RspaceStr7.ch.Ctor
16181inline  algo::RspaceStr7::RspaceStr7(const algo::RspaceStr7 &rhs) {
16182    operator =(rhs);
16183}
16184
16185// --- algo.RspaceStr7.ch.CtorStrptr
16186inline  algo::RspaceStr7::RspaceStr7(const algo::strptr &rhs) {
16187    ch_SetStrptr(*this, rhs);
16188}
16189
16190// --- algo.RspaceStr7.ch.Cast
16191inline algo::RspaceStr7::operator algo::strptr () const {
16192    return ch_Getary(*this);
16193}
16194
16195// --- algo.RspaceStr7..Cmp
16196inline i32 algo::RspaceStr7_Cmp(algo::RspaceStr7 lhs, algo::RspaceStr7 rhs) {
16197    i32 retval = 0;
16198    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16199    return retval;
16200}
16201
16202// --- algo.RspaceStr7..Init
16203// Set all fields to initial values.
16204inline void algo::RspaceStr7_Init(algo::RspaceStr7& parent) {
16205    memset(parent.ch, ' ', 7);
16206}
16207
16208// --- algo.RspaceStr7..Eq
16209inline bool algo::RspaceStr7_Eq(algo::RspaceStr7 lhs, algo::RspaceStr7 rhs) {
16210    bool retval = true;
16211    retval = retval
16212    &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
16213    &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
16214    &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
16215    return retval;
16216}
16217
16218// --- algo.RspaceStr7..EqStrptr
16219inline bool algo::RspaceStr7_EqStrptr(algo::RspaceStr7 lhs, const algo::strptr& rhs) {
16220    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16221}
16222
16223inline bool algo::RspaceStr75::operator ==(const algo::RspaceStr75 &rhs) const {
16224    return algo::RspaceStr75_Eq(const_cast<algo::RspaceStr75&>(*this),const_cast<algo::RspaceStr75&>(rhs));
16225}
16226
16227inline bool algo::RspaceStr75::operator !=(const algo::RspaceStr75 &rhs) const {
16228    return !algo::RspaceStr75_Eq(const_cast<algo::RspaceStr75&>(*this),const_cast<algo::RspaceStr75&>(rhs));
16229}
16230
16231inline bool algo::RspaceStr75::operator ==(const algo::strptr &rhs) const {
16232    return algo::RspaceStr75_EqStrptr(const_cast<algo::RspaceStr75&>(*this),rhs);
16233}
16234inline algo::RspaceStr75::RspaceStr75() {
16235    algo::RspaceStr75_Init(*this);
16236}
16237
16238
16239// --- algo.RspaceStr75.ch.Getary
16240// Access string as array of chars
16241inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr75& parent) {
16242    int len = ch_N(parent);
16243    algo::aryptr<char> ret((char*)parent.ch, len);
16244    return ret;
16245}
16246
16247// --- algo.RspaceStr75.ch.HashStrptr
16248inline u32 algo::RspaceStr75_Hash(u32 prev, const algo::strptr &str) {
16249    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16250}
16251
16252// --- algo.RspaceStr75.ch.Init
16253inline void algo::ch_Init(algo::RspaceStr75 &parent) {
16254    memset(parent.ch, ' ', 75);
16255}
16256
16257// --- algo.RspaceStr75.ch.Max
16258// always return constant 75
16259inline int algo::ch_Max(algo::RspaceStr75& parent) {
16260    (void)parent;
16261    return 75;
16262}
16263
16264// --- algo.RspaceStr75.ch.N
16265inline int algo::ch_N(const algo::RspaceStr75& parent) {
16266    u64 ret;
16267    ret = 75;
16268    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16269        ret--;
16270    }
16271    return int(ret);
16272}
16273
16274// --- algo.RspaceStr75.ch.AssignStrptr
16275// Copy from strptr (operator=)
16276inline void algo::RspaceStr75::operator =(const algo::strptr &str) {
16277    ch_SetStrptr(*this, str);
16278}
16279
16280// --- algo.RspaceStr75.ch.Set
16281// Copy from same type
16282// Copy value from RHS.
16283inline void algo::RspaceStr75::operator =(const algo::RspaceStr75& parent) {
16284    memcpy(ch, parent.ch, 75);
16285}
16286
16287// --- algo.RspaceStr75.ch.Ctor
16288inline  algo::RspaceStr75::RspaceStr75(const algo::RspaceStr75 &rhs) {
16289    operator =(rhs);
16290}
16291
16292// --- algo.RspaceStr75.ch.CtorStrptr
16293inline  algo::RspaceStr75::RspaceStr75(const algo::strptr &rhs) {
16294    ch_SetStrptr(*this, rhs);
16295}
16296
16297// --- algo.RspaceStr75.ch.Cast
16298inline algo::RspaceStr75::operator algo::strptr () const {
16299    return ch_Getary(*this);
16300}
16301
16302// --- algo.RspaceStr75..Cmp
16303inline i32 algo::RspaceStr75_Cmp(algo::RspaceStr75 lhs, algo::RspaceStr75 rhs) {
16304    i32 retval = 0;
16305    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16306    return retval;
16307}
16308
16309// --- algo.RspaceStr75..Init
16310// Set all fields to initial values.
16311inline void algo::RspaceStr75_Init(algo::RspaceStr75& parent) {
16312    memset(parent.ch, ' ', 75);
16313}
16314
16315// --- algo.RspaceStr75..Eq
16316inline bool algo::RspaceStr75_Eq(algo::RspaceStr75 lhs, algo::RspaceStr75 rhs) {
16317    bool retval = true;
16318    retval = retval
16319    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
16320    &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
16321    &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
16322    &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
16323    &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
16324    &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
16325    &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
16326    &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
16327    &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
16328    &&*(u16*)(lhs.ch+72) == *(u16*)(rhs.ch+72)
16329    &&*(u8*)(lhs.ch+74) == *(u8*)(rhs.ch+74);
16330    return retval;
16331}
16332
16333// --- algo.RspaceStr75..EqStrptr
16334inline bool algo::RspaceStr75_EqStrptr(algo::RspaceStr75 lhs, const algo::strptr& rhs) {
16335    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16336}
16337inline algo::RspaceStr8::RspaceStr8() {
16338    algo::RspaceStr8_Init(*this);
16339}
16340
16341
16342// --- algo.RspaceStr8.ch.Getary
16343// Access string as array of chars
16344inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr8& parent) {
16345    int len = ch_N(parent);
16346    algo::aryptr<char> ret((char*)parent.ch, len);
16347    return ret;
16348}
16349
16350// --- algo.RspaceStr8.ch.HashStrptr
16351inline u32 algo::RspaceStr8_Hash(u32 prev, const algo::strptr &str) {
16352    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16353}
16354
16355// --- algo.RspaceStr8.ch.Init
16356inline void algo::ch_Init(algo::RspaceStr8 &parent) {
16357    memset(parent.ch, ' ', 8);
16358}
16359
16360// --- algo.RspaceStr8.ch.Max
16361// always return constant 8
16362inline int algo::ch_Max(algo::RspaceStr8& parent) {
16363    (void)parent;
16364    return 8;
16365}
16366
16367// --- algo.RspaceStr8.ch.N
16368inline int algo::ch_N(const algo::RspaceStr8& parent) {
16369    u64 ret;
16370    ret = 8;
16371    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16372        ret--;
16373    }
16374    return int(ret);
16375}
16376
16377// --- algo.RspaceStr8.ch.AssignStrptr
16378// Copy from strptr (operator=)
16379inline void algo::RspaceStr8::operator =(const algo::strptr &str) {
16380    ch_SetStrptr(*this, str);
16381}
16382
16383// --- algo.RspaceStr8.ch.Set
16384// Copy from same type
16385// Copy value from RHS.
16386inline void algo::RspaceStr8::operator =(const algo::RspaceStr8& parent) {
16387    memcpy(ch, parent.ch, 8);
16388}
16389
16390// --- algo.RspaceStr8.ch.Ctor
16391inline  algo::RspaceStr8::RspaceStr8(const algo::RspaceStr8 &rhs) {
16392    operator =(rhs);
16393}
16394
16395// --- algo.RspaceStr8.ch.CtorStrptr
16396inline  algo::RspaceStr8::RspaceStr8(const algo::strptr &rhs) {
16397    ch_SetStrptr(*this, rhs);
16398}
16399
16400// --- algo.RspaceStr8.ch.Cast
16401inline algo::RspaceStr8::operator algo::strptr () const {
16402    return ch_Getary(*this);
16403}
16404
16405// --- algo.RspaceStr8..Lt
16406inline bool algo::RspaceStr8_Lt(algo::RspaceStr8 lhs, algo::RspaceStr8 rhs) {
16407    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
16408}
16409
16410// --- algo.RspaceStr8..Cmp
16411inline i32 algo::RspaceStr8_Cmp(algo::RspaceStr8 lhs, algo::RspaceStr8 rhs) {
16412    i32 retval = 0;
16413    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16414    return retval;
16415}
16416
16417// --- algo.RspaceStr8..Init
16418// Set all fields to initial values.
16419inline void algo::RspaceStr8_Init(algo::RspaceStr8& parent) {
16420    memset(parent.ch, ' ', 8);
16421}
16422
16423// --- algo.RspaceStr8..Eq
16424inline bool algo::RspaceStr8_Eq(algo::RspaceStr8 lhs, algo::RspaceStr8 rhs) {
16425    bool retval = true;
16426    retval = retval
16427    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
16428    return retval;
16429}
16430
16431// --- algo.RspaceStr8..Update
16432// Set value. Return true if new value is different from old value.
16433inline bool algo::RspaceStr8_Update(algo::RspaceStr8 &lhs, algo::RspaceStr8 rhs) {
16434    bool ret = !RspaceStr8_Eq(lhs, rhs); // compare values
16435    if (ret) {
16436        lhs = rhs; // update
16437    }
16438    return ret;
16439}
16440
16441// --- algo.RspaceStr8..EqStrptr
16442inline bool algo::RspaceStr8_EqStrptr(algo::RspaceStr8 lhs, const algo::strptr& rhs) {
16443    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16444}
16445
16446inline bool algo::RspaceStr9::operator ==(const algo::RspaceStr9 &rhs) const {
16447    return algo::RspaceStr9_Eq(const_cast<algo::RspaceStr9&>(*this),const_cast<algo::RspaceStr9&>(rhs));
16448}
16449
16450inline bool algo::RspaceStr9::operator !=(const algo::RspaceStr9 &rhs) const {
16451    return !algo::RspaceStr9_Eq(const_cast<algo::RspaceStr9&>(*this),const_cast<algo::RspaceStr9&>(rhs));
16452}
16453
16454inline bool algo::RspaceStr9::operator ==(const algo::strptr &rhs) const {
16455    return algo::RspaceStr9_EqStrptr(const_cast<algo::RspaceStr9&>(*this),rhs);
16456}
16457inline algo::RspaceStr9::RspaceStr9() {
16458    algo::RspaceStr9_Init(*this);
16459}
16460
16461
16462// --- algo.RspaceStr9.ch.Getary
16463// Access string as array of chars
16464inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr9& parent) {
16465    int len = ch_N(parent);
16466    algo::aryptr<char> ret((char*)parent.ch, len);
16467    return ret;
16468}
16469
16470// --- algo.RspaceStr9.ch.HashStrptr
16471inline u32 algo::RspaceStr9_Hash(u32 prev, const algo::strptr &str) {
16472    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16473}
16474
16475// --- algo.RspaceStr9.ch.Init
16476inline void algo::ch_Init(algo::RspaceStr9 &parent) {
16477    memset(parent.ch, ' ', 9);
16478}
16479
16480// --- algo.RspaceStr9.ch.Max
16481// always return constant 9
16482inline int algo::ch_Max(algo::RspaceStr9& parent) {
16483    (void)parent;
16484    return 9;
16485}
16486
16487// --- algo.RspaceStr9.ch.N
16488inline int algo::ch_N(const algo::RspaceStr9& parent) {
16489    u64 ret;
16490    ret = 9;
16491    while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16492        ret--;
16493    }
16494    return int(ret);
16495}
16496
16497// --- algo.RspaceStr9.ch.AssignStrptr
16498// Copy from strptr (operator=)
16499inline void algo::RspaceStr9::operator =(const algo::strptr &str) {
16500    ch_SetStrptr(*this, str);
16501}
16502
16503// --- algo.RspaceStr9.ch.Set
16504// Copy from same type
16505// Copy value from RHS.
16506inline void algo::RspaceStr9::operator =(const algo::RspaceStr9& parent) {
16507    memcpy(ch, parent.ch, 9);
16508}
16509
16510// --- algo.RspaceStr9.ch.Ctor
16511inline  algo::RspaceStr9::RspaceStr9(const algo::RspaceStr9 &rhs) {
16512    operator =(rhs);
16513}
16514
16515// --- algo.RspaceStr9.ch.CtorStrptr
16516inline  algo::RspaceStr9::RspaceStr9(const algo::strptr &rhs) {
16517    ch_SetStrptr(*this, rhs);
16518}
16519
16520// --- algo.RspaceStr9.ch.Cast
16521inline algo::RspaceStr9::operator algo::strptr () const {
16522    return ch_Getary(*this);
16523}
16524
16525// --- algo.RspaceStr9..Cmp
16526inline i32 algo::RspaceStr9_Cmp(algo::RspaceStr9& lhs, algo::RspaceStr9& rhs) {
16527    i32 retval = 0;
16528    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16529    return retval;
16530}
16531
16532// --- algo.RspaceStr9..Init
16533// Set all fields to initial values.
16534inline void algo::RspaceStr9_Init(algo::RspaceStr9& parent) {
16535    memset(parent.ch, ' ', 9);
16536}
16537
16538// --- algo.RspaceStr9..Eq
16539inline bool algo::RspaceStr9_Eq(algo::RspaceStr9& lhs, algo::RspaceStr9& rhs) {
16540    bool retval = true;
16541    retval = retval
16542    &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
16543    &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
16544    return retval;
16545}
16546
16547// --- algo.RspaceStr9..EqStrptr
16548inline bool algo::RspaceStr9_EqStrptr(const algo::RspaceStr9& lhs, const algo::strptr& rhs) {
16549    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16550}
16551inline algo::SchedTime::SchedTime(u64                            in_value)
16552    : value(in_value)
16553{
16554}
16555inline algo::SchedTime::SchedTime() {
16556    algo::SchedTime_Init(*this);
16557}
16558
16559
16560// --- algo.SchedTime.value.Cast
16561inline algo::SchedTime::operator u64 () const {
16562    return u64((*this).value);
16563}
16564
16565// --- algo.SchedTime..Lt
16566inline bool algo::SchedTime_Lt(algo::SchedTime lhs, algo::SchedTime rhs) {
16567    return u64_Lt(lhs.value, rhs.value);
16568}
16569
16570// --- algo.SchedTime..Cmp
16571inline i32 algo::SchedTime_Cmp(algo::SchedTime lhs, algo::SchedTime rhs) {
16572    i32 retval = 0;
16573    retval = u64_Cmp(lhs.value, rhs.value);
16574    return retval;
16575}
16576
16577// --- algo.SchedTime..Init
16578// Set all fields to initial values.
16579inline void algo::SchedTime_Init(algo::SchedTime& parent) {
16580    parent.value = u64(0);
16581}
16582
16583// --- algo.SchedTime..Eq
16584inline bool algo::SchedTime_Eq(algo::SchedTime lhs, algo::SchedTime rhs) {
16585    bool retval = true;
16586    retval = u64_Eq(lhs.value, rhs.value);
16587    return retval;
16588}
16589
16590// --- algo.SchedTime..Update
16591// Set value. Return true if new value is different from old value.
16592inline bool algo::SchedTime_Update(algo::SchedTime &lhs, algo::SchedTime rhs) {
16593    bool ret = !SchedTime_Eq(lhs, rhs); // compare values
16594    if (ret) {
16595        lhs = rhs; // update
16596    }
16597    return ret;
16598}
16599inline algo::SeqType::SeqType(u64                            in_value)
16600    : value(in_value)
16601{
16602}
16603inline algo::SeqType::SeqType() {
16604    algo::SeqType_Init(*this);
16605}
16606
16607
16608// --- algo.SeqType.value.Cast
16609inline algo::SeqType::operator u64 () const {
16610    return u64((*this).value);
16611}
16612
16613// --- algo.SeqType..Hash
16614inline u32 algo::SeqType_Hash(u32 prev, algo::SeqType rhs) {
16615    prev = u64_Hash(prev, rhs.value);
16616    return prev;
16617}
16618
16619// --- algo.SeqType..Lt
16620inline bool algo::SeqType_Lt(algo::SeqType lhs, algo::SeqType rhs) {
16621    return u64_Lt(lhs.value, rhs.value);
16622}
16623
16624// --- algo.SeqType..Cmp
16625inline i32 algo::SeqType_Cmp(algo::SeqType lhs, algo::SeqType rhs) {
16626    i32 retval = 0;
16627    retval = u64_Cmp(lhs.value, rhs.value);
16628    return retval;
16629}
16630
16631// --- algo.SeqType..Init
16632// Set all fields to initial values.
16633inline void algo::SeqType_Init(algo::SeqType& parent) {
16634    parent.value = u64(0);
16635}
16636
16637// --- algo.SeqType..Eq
16638inline bool algo::SeqType_Eq(algo::SeqType lhs, algo::SeqType rhs) {
16639    bool retval = true;
16640    retval = u64_Eq(lhs.value, rhs.value);
16641    return retval;
16642}
16643
16644// --- algo.SeqType..Update
16645// Set value. Return true if new value is different from old value.
16646inline bool algo::SeqType_Update(algo::SeqType &lhs, algo::SeqType rhs) {
16647    bool ret = !SeqType_Eq(lhs, rhs); // compare values
16648    if (ret) {
16649        lhs = rhs; // update
16650    }
16651    return ret;
16652}
16653
16654inline bool algo::Sha1sig::operator ==(const algo::Sha1sig &rhs) const {
16655    return algo::Sha1sig_Eq(const_cast<algo::Sha1sig&>(*this),const_cast<algo::Sha1sig&>(rhs));
16656}
16657
16658inline bool algo::Sha1sig::operator !=(const algo::Sha1sig &rhs) const {
16659    return !algo::Sha1sig_Eq(const_cast<algo::Sha1sig&>(*this),const_cast<algo::Sha1sig&>(rhs));
16660}
16661
16662inline bool algo::Sha1sig::operator <(const algo::Sha1sig &rhs) const {
16663    return algo::Sha1sig_Lt(const_cast<algo::Sha1sig&>(*this),const_cast<algo::Sha1sig&>(rhs));
16664}
16665
16666inline bool algo::Sha1sig::operator >(const algo::Sha1sig &rhs) const {
16667    return rhs < *this;
16668}
16669
16670inline bool algo::Sha1sig::operator <=(const algo::Sha1sig &rhs) const {
16671    return !(rhs < *this);
16672}
16673
16674inline bool algo::Sha1sig::operator >=(const algo::Sha1sig &rhs) const {
16675    return !(*this < rhs);
16676}
16677inline algo::Sha1sig::Sha1sig() {
16678    algo::Sha1sig_Init(*this);
16679}
16680
16681
16682// --- algo.Sha1sig.sha1sig.Fill
16683// Set all elements of fixed array to value RHS
16684inline void algo::sha1sig_Fill(algo::Sha1sig& parent, const u8 &rhs) {
16685    for (int i = 0; i < 20; i++) {
16686        parent.sha1sig_elems[i] = rhs;
16687    }
16688}
16689
16690// --- algo.Sha1sig.sha1sig.Find
16691// Look up row by row id. Return NULL if out of range
16692inline u8* algo::sha1sig_Find(algo::Sha1sig& parent, u64 t) {
16693    u64 idx = t;
16694    u64 lim = 20;
16695    return idx < lim ? parent.sha1sig_elems + idx : NULL; // unsigned comparison with limit
16696}
16697
16698// --- algo.Sha1sig.sha1sig.Getary
16699// Access fixed array sha1sig as aryptr.
16700inline algo::aryptr<u8> algo::sha1sig_Getary(algo::Sha1sig& parent) {
16701    return algo::aryptr<u8>(parent.sha1sig_elems, 20);
16702}
16703
16704// --- algo.Sha1sig.sha1sig.Max
16705// Return max number of items in the array
16706inline i32 algo::sha1sig_Max(algo::Sha1sig& parent) {
16707    (void)parent;
16708    return 20;
16709}
16710
16711// --- algo.Sha1sig.sha1sig.N
16712// Return number of items in the array
16713inline i32 algo::sha1sig_N(const algo::Sha1sig& parent) {
16714    (void)parent;//only to avoid -Wunused-parameter
16715    return 20;
16716}
16717
16718// --- algo.Sha1sig.sha1sig.Setary
16719// Set contents of fixed array to RHS; Input length is trimmed as necessary
16720inline void algo::sha1sig_Setary(algo::Sha1sig& parent, const algo::aryptr<u8> &rhs) {
16721    int n = 20 < rhs.n_elems ? 20 : rhs.n_elems;
16722    for (int i = 0; i < n; i++) {
16723        parent.sha1sig_elems[i] = rhs[i];
16724    }
16725}
16726
16727// --- algo.Sha1sig.sha1sig.qFind
16728// 'quick' Access row by row id. No bounds checking in release.
16729inline u8& algo::sha1sig_qFind(algo::Sha1sig& parent, u64 t) {
16730    return parent.sha1sig_elems[u64(t)];
16731}
16732
16733// --- algo.Sha1sig.sha1sig_curs.Reset
16734// cursor points to valid item
16735inline void algo::Sha1sig_sha1sig_curs_Reset(Sha1sig_sha1sig_curs &curs, algo::Sha1sig &parent) {
16736    curs.parent = &parent;
16737    curs.index = 0;
16738}
16739
16740// --- algo.Sha1sig.sha1sig_curs.ValidQ
16741// cursor points to valid item
16742inline bool algo::Sha1sig_sha1sig_curs_ValidQ(Sha1sig_sha1sig_curs &curs) {
16743    return u64(curs.index) < u64(20);
16744}
16745
16746// --- algo.Sha1sig.sha1sig_curs.Next
16747// proceed to next item
16748inline void algo::Sha1sig_sha1sig_curs_Next(Sha1sig_sha1sig_curs &curs) {
16749    curs.index++;
16750}
16751
16752// --- algo.Sha1sig.sha1sig_curs.Access
16753// item access
16754inline u8& algo::Sha1sig_sha1sig_curs_Access(Sha1sig_sha1sig_curs &curs) {
16755    return sha1sig_qFind((*curs.parent), u64(curs.index));
16756}
16757
16758// --- algo.Sha1sig..Lt
16759inline bool algo::Sha1sig_Lt(algo::Sha1sig& lhs, algo::Sha1sig& rhs) {
16760    return sha1sig_Cmp(lhs,rhs) < 0;
16761}
16762
16763// --- algo.Sha1sig..Cmp
16764inline i32 algo::Sha1sig_Cmp(algo::Sha1sig& lhs, algo::Sha1sig& rhs) {
16765    i32 retval = 0;
16766    retval = sha1sig_Cmp(lhs,rhs);
16767    return retval;
16768}
16769
16770// --- algo.Sha1sig..Init
16771// Set all fields to initial values.
16772inline void algo::Sha1sig_Init(algo::Sha1sig& parent) {
16773    for (int i = 0; i < 20; i++) {
16774        parent.sha1sig_elems[i] = 0;
16775    }
16776}
16777
16778// --- algo.Sha1sig..Eq
16779inline bool algo::Sha1sig_Eq(algo::Sha1sig& lhs, algo::Sha1sig& rhs) {
16780    bool retval = true;
16781    retval = sha1sig_Eq(lhs,rhs);
16782    return retval;
16783}
16784
16785// --- algo.Sha1sig..Update
16786// Set value. Return true if new value is different from old value.
16787inline bool algo::Sha1sig_Update(algo::Sha1sig &lhs, algo::Sha1sig& rhs) {
16788    bool ret = !Sha1sig_Eq(lhs, rhs); // compare values
16789    if (ret) {
16790        lhs = rhs; // update
16791    }
16792    return ret;
16793}
16794
16795inline bool algo::Smallstr1::operator ==(const algo::Smallstr1 &rhs) const {
16796    return algo::Smallstr1_Eq(const_cast<algo::Smallstr1&>(*this),const_cast<algo::Smallstr1&>(rhs));
16797}
16798
16799inline bool algo::Smallstr1::operator !=(const algo::Smallstr1 &rhs) const {
16800    return !algo::Smallstr1_Eq(const_cast<algo::Smallstr1&>(*this),const_cast<algo::Smallstr1&>(rhs));
16801}
16802
16803inline bool algo::Smallstr1::operator ==(const algo::strptr &rhs) const {
16804    return algo::Smallstr1_EqStrptr(const_cast<algo::Smallstr1&>(*this),rhs);
16805}
16806inline algo::Smallstr1::Smallstr1() {
16807    algo::Smallstr1_Init(*this);
16808}
16809
16810
16811// --- algo.Smallstr1.ch.Add
16812// Append character to string.
16813// If there is no space for an extra character, do nothing.
16814inline void algo::ch_Add(algo::Smallstr1& parent, char c) {
16815    if (parent.n_ch < 1) {
16816        parent.ch[parent.n_ch++] = c;
16817    }
16818}
16819
16820// --- algo.Smallstr1.ch.AddStrptr
16821// Append string to this string.
16822// If there is no space for an extra character, trim.
16823// If there is no space left, dump core in debug mode.
16824inline void algo::ch_AddStrptr(algo::Smallstr1& parent, algo::strptr str) {
16825    int n_new = str.n_elems;
16826    if (parent.n_ch + n_new > 1) {
16827        n_new = 1 - parent.n_ch;
16828    }
16829    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
16830    parent.n_ch = u8(parent.n_ch + n_new);
16831}
16832
16833// --- algo.Smallstr1.ch.Getary
16834// Access string as array of chars
16835inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr1& parent) {
16836    int len = ch_N(parent);
16837    algo::aryptr<char> ret((char*)parent.ch, len);
16838    return ret;
16839}
16840
16841// --- algo.Smallstr1.ch.HashStrptr
16842inline u32 algo::Smallstr1_Hash(u32 prev, const algo::strptr &str) {
16843    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16844}
16845
16846// --- algo.Smallstr1.ch.Init
16847inline void algo::ch_Init(algo::Smallstr1 &parent) {
16848    parent.n_ch = 0;
16849}
16850
16851// --- algo.Smallstr1.ch.Max
16852// always return constant 1
16853inline int algo::ch_Max(algo::Smallstr1& parent) {
16854    (void)parent;
16855    return 1;
16856}
16857
16858// --- algo.Smallstr1.ch.N
16859inline int algo::ch_N(const algo::Smallstr1& parent) {
16860    u64 ret;
16861    ret = parent.n_ch;
16862    return int(ret);
16863}
16864
16865// --- algo.Smallstr1.ch.AssignStrptr
16866// Copy from strptr (operator=)
16867inline void algo::Smallstr1::operator =(const algo::strptr &str) {
16868    ch_SetStrptr(*this, str);
16869}
16870
16871// --- algo.Smallstr1.ch.Set
16872// Copy from same type
16873// Copy value from RHS.
16874inline void algo::Smallstr1::operator =(const algo::Smallstr1& parent) {
16875    memcpy(ch, parent.ch, parent.n_ch);
16876    n_ch = parent.n_ch;
16877}
16878
16879// --- algo.Smallstr1.ch.Ctor
16880inline  algo::Smallstr1::Smallstr1(const algo::Smallstr1 &rhs) {
16881    operator =(rhs);
16882}
16883
16884// --- algo.Smallstr1.ch.CtorStrptr
16885inline  algo::Smallstr1::Smallstr1(const algo::strptr &rhs) {
16886    ch_SetStrptr(*this, rhs);
16887}
16888
16889// --- algo.Smallstr1.ch.Cast
16890inline algo::Smallstr1::operator algo::strptr () const {
16891    return ch_Getary(*this);
16892}
16893
16894// --- algo.Smallstr1..Cmp
16895inline i32 algo::Smallstr1_Cmp(algo::Smallstr1& lhs, algo::Smallstr1& rhs) {
16896    i32 retval = 0;
16897    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16898    return retval;
16899}
16900
16901// --- algo.Smallstr1..Init
16902// Set all fields to initial values.
16903inline void algo::Smallstr1_Init(algo::Smallstr1& parent) {
16904    parent.n_ch = 0;
16905}
16906
16907// --- algo.Smallstr1..Eq
16908inline bool algo::Smallstr1_Eq(algo::Smallstr1& lhs, algo::Smallstr1& rhs) {
16909    bool retval = true;
16910    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
16911    return retval;
16912}
16913
16914// --- algo.Smallstr1..EqStrptr
16915inline bool algo::Smallstr1_EqStrptr(const algo::Smallstr1& lhs, const algo::strptr& rhs) {
16916    return algo::strptr_Eq(ch_Getary(lhs), rhs);
16917}
16918
16919inline bool algo::Smallstr10::operator ==(const algo::Smallstr10 &rhs) const {
16920    return algo::Smallstr10_Eq(const_cast<algo::Smallstr10&>(*this),const_cast<algo::Smallstr10&>(rhs));
16921}
16922
16923inline bool algo::Smallstr10::operator !=(const algo::Smallstr10 &rhs) const {
16924    return !algo::Smallstr10_Eq(const_cast<algo::Smallstr10&>(*this),const_cast<algo::Smallstr10&>(rhs));
16925}
16926
16927inline bool algo::Smallstr10::operator ==(const algo::strptr &rhs) const {
16928    return algo::Smallstr10_EqStrptr(const_cast<algo::Smallstr10&>(*this),rhs);
16929}
16930inline algo::Smallstr10::Smallstr10() {
16931    algo::Smallstr10_Init(*this);
16932}
16933
16934
16935// --- algo.Smallstr10.ch.Add
16936// Append character to string.
16937// If there is no space for an extra character, do nothing.
16938inline void algo::ch_Add(algo::Smallstr10& parent, char c) {
16939    if (parent.n_ch < 10) {
16940        parent.ch[parent.n_ch++] = c;
16941    }
16942}
16943
16944// --- algo.Smallstr10.ch.AddStrptr
16945// Append string to this string.
16946// If there is no space for an extra character, trim.
16947// If there is no space left, dump core in debug mode.
16948inline void algo::ch_AddStrptr(algo::Smallstr10& parent, algo::strptr str) {
16949    int n_new = str.n_elems;
16950    if (parent.n_ch + n_new > 10) {
16951        n_new = 10 - parent.n_ch;
16952    }
16953    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
16954    parent.n_ch = u8(parent.n_ch + n_new);
16955}
16956
16957// --- algo.Smallstr10.ch.Getary
16958// Access string as array of chars
16959inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr10& parent) {
16960    int len = ch_N(parent);
16961    algo::aryptr<char> ret((char*)parent.ch, len);
16962    return ret;
16963}
16964
16965// --- algo.Smallstr10.ch.HashStrptr
16966inline u32 algo::Smallstr10_Hash(u32 prev, const algo::strptr &str) {
16967    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16968}
16969
16970// --- algo.Smallstr10.ch.Init
16971inline void algo::ch_Init(algo::Smallstr10 &parent) {
16972    parent.n_ch = 0;
16973}
16974
16975// --- algo.Smallstr10.ch.Max
16976// always return constant 10
16977inline int algo::ch_Max(algo::Smallstr10& parent) {
16978    (void)parent;
16979    return 10;
16980}
16981
16982// --- algo.Smallstr10.ch.N
16983inline int algo::ch_N(const algo::Smallstr10& parent) {
16984    u64 ret;
16985    ret = parent.n_ch;
16986    return int(ret);
16987}
16988
16989// --- algo.Smallstr10.ch.AssignStrptr
16990// Copy from strptr (operator=)
16991inline void algo::Smallstr10::operator =(const algo::strptr &str) {
16992    ch_SetStrptr(*this, str);
16993}
16994
16995// --- algo.Smallstr10.ch.Set
16996// Copy from same type
16997// Copy value from RHS.
16998inline void algo::Smallstr10::operator =(const algo::Smallstr10& parent) {
16999    memcpy(ch, parent.ch, parent.n_ch);
17000    n_ch = parent.n_ch;
17001}
17002
17003// --- algo.Smallstr10.ch.Ctor
17004inline  algo::Smallstr10::Smallstr10(const algo::Smallstr10 &rhs) {
17005    operator =(rhs);
17006}
17007
17008// --- algo.Smallstr10.ch.CtorStrptr
17009inline  algo::Smallstr10::Smallstr10(const algo::strptr &rhs) {
17010    ch_SetStrptr(*this, rhs);
17011}
17012
17013// --- algo.Smallstr10.ch.Cast
17014inline algo::Smallstr10::operator algo::strptr () const {
17015    return ch_Getary(*this);
17016}
17017
17018// --- algo.Smallstr10..Cmp
17019inline i32 algo::Smallstr10_Cmp(algo::Smallstr10& lhs, algo::Smallstr10& rhs) {
17020    i32 retval = 0;
17021    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17022    return retval;
17023}
17024
17025// --- algo.Smallstr10..Init
17026// Set all fields to initial values.
17027inline void algo::Smallstr10_Init(algo::Smallstr10& parent) {
17028    parent.n_ch = 0;
17029}
17030
17031// --- algo.Smallstr10..Eq
17032inline bool algo::Smallstr10_Eq(algo::Smallstr10& lhs, algo::Smallstr10& rhs) {
17033    bool retval = true;
17034    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17035    return retval;
17036}
17037
17038// --- algo.Smallstr10..EqStrptr
17039inline bool algo::Smallstr10_EqStrptr(const algo::Smallstr10& lhs, const algo::strptr& rhs) {
17040    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17041}
17042
17043inline bool algo::Smallstr16::operator ==(const algo::Smallstr16 &rhs) const {
17044    return algo::Smallstr16_Eq(const_cast<algo::Smallstr16&>(*this),const_cast<algo::Smallstr16&>(rhs));
17045}
17046
17047inline bool algo::Smallstr16::operator !=(const algo::Smallstr16 &rhs) const {
17048    return !algo::Smallstr16_Eq(const_cast<algo::Smallstr16&>(*this),const_cast<algo::Smallstr16&>(rhs));
17049}
17050
17051inline bool algo::Smallstr16::operator ==(const algo::strptr &rhs) const {
17052    return algo::Smallstr16_EqStrptr(const_cast<algo::Smallstr16&>(*this),rhs);
17053}
17054inline algo::Smallstr16::Smallstr16() {
17055    algo::Smallstr16_Init(*this);
17056}
17057
17058
17059// --- algo.Smallstr16.ch.Add
17060// Append character to string.
17061// If there is no space for an extra character, do nothing.
17062inline void algo::ch_Add(algo::Smallstr16& parent, char c) {
17063    if (parent.n_ch < 16) {
17064        parent.ch[parent.n_ch++] = c;
17065    }
17066}
17067
17068// --- algo.Smallstr16.ch.AddStrptr
17069// Append string to this string.
17070// If there is no space for an extra character, trim.
17071// If there is no space left, dump core in debug mode.
17072inline void algo::ch_AddStrptr(algo::Smallstr16& parent, algo::strptr str) {
17073    int n_new = str.n_elems;
17074    if (parent.n_ch + n_new > 16) {
17075        n_new = 16 - parent.n_ch;
17076    }
17077    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17078    parent.n_ch = u8(parent.n_ch + n_new);
17079}
17080
17081// --- algo.Smallstr16.ch.Getary
17082// Access string as array of chars
17083inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr16& parent) {
17084    int len = ch_N(parent);
17085    algo::aryptr<char> ret((char*)parent.ch, len);
17086    return ret;
17087}
17088
17089// --- algo.Smallstr16.ch.HashStrptr
17090inline u32 algo::Smallstr16_Hash(u32 prev, const algo::strptr &str) {
17091    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17092}
17093
17094// --- algo.Smallstr16.ch.Init
17095inline void algo::ch_Init(algo::Smallstr16 &parent) {
17096    parent.n_ch = 0;
17097}
17098
17099// --- algo.Smallstr16.ch.Max
17100// always return constant 16
17101inline int algo::ch_Max(algo::Smallstr16& parent) {
17102    (void)parent;
17103    return 16;
17104}
17105
17106// --- algo.Smallstr16.ch.N
17107inline int algo::ch_N(const algo::Smallstr16& parent) {
17108    u64 ret;
17109    ret = parent.n_ch;
17110    return int(ret);
17111}
17112
17113// --- algo.Smallstr16.ch.AssignStrptr
17114// Copy from strptr (operator=)
17115inline void algo::Smallstr16::operator =(const algo::strptr &str) {
17116    ch_SetStrptr(*this, str);
17117}
17118
17119// --- algo.Smallstr16.ch.Set
17120// Copy from same type
17121// Copy value from RHS.
17122inline void algo::Smallstr16::operator =(const algo::Smallstr16& parent) {
17123    memcpy(ch, parent.ch, parent.n_ch);
17124    n_ch = parent.n_ch;
17125}
17126
17127// --- algo.Smallstr16.ch.Ctor
17128inline  algo::Smallstr16::Smallstr16(const algo::Smallstr16 &rhs) {
17129    operator =(rhs);
17130}
17131
17132// --- algo.Smallstr16.ch.CtorStrptr
17133inline  algo::Smallstr16::Smallstr16(const algo::strptr &rhs) {
17134    ch_SetStrptr(*this, rhs);
17135}
17136
17137// --- algo.Smallstr16.ch.Cast
17138inline algo::Smallstr16::operator algo::strptr () const {
17139    return ch_Getary(*this);
17140}
17141
17142// --- algo.Smallstr16..Cmp
17143inline i32 algo::Smallstr16_Cmp(algo::Smallstr16& lhs, algo::Smallstr16& rhs) {
17144    i32 retval = 0;
17145    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17146    return retval;
17147}
17148
17149// --- algo.Smallstr16..Init
17150// Set all fields to initial values.
17151inline void algo::Smallstr16_Init(algo::Smallstr16& parent) {
17152    parent.n_ch = 0;
17153}
17154
17155// --- algo.Smallstr16..Eq
17156inline bool algo::Smallstr16_Eq(algo::Smallstr16& lhs, algo::Smallstr16& rhs) {
17157    bool retval = true;
17158    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17159    return retval;
17160}
17161
17162// --- algo.Smallstr16..EqStrptr
17163inline bool algo::Smallstr16_EqStrptr(const algo::Smallstr16& lhs, const algo::strptr& rhs) {
17164    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17165}
17166
17167inline bool algo::Smallstr2::operator ==(const algo::Smallstr2 &rhs) const {
17168    return algo::Smallstr2_Eq(const_cast<algo::Smallstr2&>(*this),const_cast<algo::Smallstr2&>(rhs));
17169}
17170
17171inline bool algo::Smallstr2::operator !=(const algo::Smallstr2 &rhs) const {
17172    return !algo::Smallstr2_Eq(const_cast<algo::Smallstr2&>(*this),const_cast<algo::Smallstr2&>(rhs));
17173}
17174
17175inline bool algo::Smallstr2::operator ==(const algo::strptr &rhs) const {
17176    return algo::Smallstr2_EqStrptr(const_cast<algo::Smallstr2&>(*this),rhs);
17177}
17178inline algo::Smallstr2::Smallstr2() {
17179    algo::Smallstr2_Init(*this);
17180}
17181
17182
17183// --- algo.Smallstr2.ch.Add
17184// Append character to string.
17185// If there is no space for an extra character, do nothing.
17186inline void algo::ch_Add(algo::Smallstr2& parent, char c) {
17187    if (parent.n_ch < 2) {
17188        parent.ch[parent.n_ch++] = c;
17189    }
17190}
17191
17192// --- algo.Smallstr2.ch.AddStrptr
17193// Append string to this string.
17194// If there is no space for an extra character, trim.
17195// If there is no space left, dump core in debug mode.
17196inline void algo::ch_AddStrptr(algo::Smallstr2& parent, algo::strptr str) {
17197    int n_new = str.n_elems;
17198    if (parent.n_ch + n_new > 2) {
17199        n_new = 2 - parent.n_ch;
17200    }
17201    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17202    parent.n_ch = u8(parent.n_ch + n_new);
17203}
17204
17205// --- algo.Smallstr2.ch.Getary
17206// Access string as array of chars
17207inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr2& parent) {
17208    int len = ch_N(parent);
17209    algo::aryptr<char> ret((char*)parent.ch, len);
17210    return ret;
17211}
17212
17213// --- algo.Smallstr2.ch.HashStrptr
17214inline u32 algo::Smallstr2_Hash(u32 prev, const algo::strptr &str) {
17215    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17216}
17217
17218// --- algo.Smallstr2.ch.Init
17219inline void algo::ch_Init(algo::Smallstr2 &parent) {
17220    parent.n_ch = 0;
17221}
17222
17223// --- algo.Smallstr2.ch.Max
17224// always return constant 2
17225inline int algo::ch_Max(algo::Smallstr2& parent) {
17226    (void)parent;
17227    return 2;
17228}
17229
17230// --- algo.Smallstr2.ch.N
17231inline int algo::ch_N(const algo::Smallstr2& parent) {
17232    u64 ret;
17233    ret = parent.n_ch;
17234    return int(ret);
17235}
17236
17237// --- algo.Smallstr2.ch.AssignStrptr
17238// Copy from strptr (operator=)
17239inline void algo::Smallstr2::operator =(const algo::strptr &str) {
17240    ch_SetStrptr(*this, str);
17241}
17242
17243// --- algo.Smallstr2.ch.Set
17244// Copy from same type
17245// Copy value from RHS.
17246inline void algo::Smallstr2::operator =(const algo::Smallstr2& parent) {
17247    memcpy(ch, parent.ch, parent.n_ch);
17248    n_ch = parent.n_ch;
17249}
17250
17251// --- algo.Smallstr2.ch.Ctor
17252inline  algo::Smallstr2::Smallstr2(const algo::Smallstr2 &rhs) {
17253    operator =(rhs);
17254}
17255
17256// --- algo.Smallstr2.ch.CtorStrptr
17257inline  algo::Smallstr2::Smallstr2(const algo::strptr &rhs) {
17258    ch_SetStrptr(*this, rhs);
17259}
17260
17261// --- algo.Smallstr2.ch.Cast
17262inline algo::Smallstr2::operator algo::strptr () const {
17263    return ch_Getary(*this);
17264}
17265
17266// --- algo.Smallstr2..Cmp
17267inline i32 algo::Smallstr2_Cmp(algo::Smallstr2& lhs, algo::Smallstr2& rhs) {
17268    i32 retval = 0;
17269    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17270    return retval;
17271}
17272
17273// --- algo.Smallstr2..Init
17274// Set all fields to initial values.
17275inline void algo::Smallstr2_Init(algo::Smallstr2& parent) {
17276    parent.n_ch = 0;
17277}
17278
17279// --- algo.Smallstr2..Eq
17280inline bool algo::Smallstr2_Eq(algo::Smallstr2& lhs, algo::Smallstr2& rhs) {
17281    bool retval = true;
17282    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17283    return retval;
17284}
17285
17286// --- algo.Smallstr2..EqStrptr
17287inline bool algo::Smallstr2_EqStrptr(const algo::Smallstr2& lhs, const algo::strptr& rhs) {
17288    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17289}
17290
17291inline bool algo::Smallstr20::operator ==(const algo::Smallstr20 &rhs) const {
17292    return algo::Smallstr20_Eq(const_cast<algo::Smallstr20&>(*this),const_cast<algo::Smallstr20&>(rhs));
17293}
17294
17295inline bool algo::Smallstr20::operator !=(const algo::Smallstr20 &rhs) const {
17296    return !algo::Smallstr20_Eq(const_cast<algo::Smallstr20&>(*this),const_cast<algo::Smallstr20&>(rhs));
17297}
17298
17299inline bool algo::Smallstr20::operator ==(const algo::strptr &rhs) const {
17300    return algo::Smallstr20_EqStrptr(const_cast<algo::Smallstr20&>(*this),rhs);
17301}
17302
17303inline bool algo::Smallstr20::operator <(const algo::Smallstr20 &rhs) const {
17304    return algo::Smallstr20_Lt(const_cast<algo::Smallstr20&>(*this),const_cast<algo::Smallstr20&>(rhs));
17305}
17306
17307inline bool algo::Smallstr20::operator >(const algo::Smallstr20 &rhs) const {
17308    return rhs < *this;
17309}
17310
17311inline bool algo::Smallstr20::operator <=(const algo::Smallstr20 &rhs) const {
17312    return !(rhs < *this);
17313}
17314
17315inline bool algo::Smallstr20::operator >=(const algo::Smallstr20 &rhs) const {
17316    return !(*this < rhs);
17317}
17318inline algo::Smallstr20::Smallstr20() {
17319    algo::Smallstr20_Init(*this);
17320}
17321
17322
17323// --- algo.Smallstr20.ch.Add
17324// Append character to string.
17325// If there is no space for an extra character, do nothing.
17326inline void algo::ch_Add(algo::Smallstr20& parent, char c) {
17327    if (parent.n_ch < 20) {
17328        parent.ch[parent.n_ch++] = c;
17329    }
17330}
17331
17332// --- algo.Smallstr20.ch.AddStrptr
17333// Append string to this string.
17334// If there is no space for an extra character, trim.
17335// If there is no space left, dump core in debug mode.
17336inline void algo::ch_AddStrptr(algo::Smallstr20& parent, algo::strptr str) {
17337    int n_new = str.n_elems;
17338    if (parent.n_ch + n_new > 20) {
17339        n_new = 20 - parent.n_ch;
17340    }
17341    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17342    parent.n_ch = u8(parent.n_ch + n_new);
17343}
17344
17345// --- algo.Smallstr20.ch.Getary
17346// Access string as array of chars
17347inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr20& parent) {
17348    int len = ch_N(parent);
17349    algo::aryptr<char> ret((char*)parent.ch, len);
17350    return ret;
17351}
17352
17353// --- algo.Smallstr20.ch.HashStrptr
17354inline u32 algo::Smallstr20_Hash(u32 prev, const algo::strptr &str) {
17355    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17356}
17357
17358// --- algo.Smallstr20.ch.Init
17359inline void algo::ch_Init(algo::Smallstr20 &parent) {
17360    parent.n_ch = 0;
17361}
17362
17363// --- algo.Smallstr20.ch.Max
17364// always return constant 20
17365inline int algo::ch_Max(algo::Smallstr20& parent) {
17366    (void)parent;
17367    return 20;
17368}
17369
17370// --- algo.Smallstr20.ch.N
17371inline int algo::ch_N(const algo::Smallstr20& parent) {
17372    u64 ret;
17373    ret = parent.n_ch;
17374    return int(ret);
17375}
17376
17377// --- algo.Smallstr20.ch.AssignStrptr
17378// Copy from strptr (operator=)
17379inline void algo::Smallstr20::operator =(const algo::strptr &str) {
17380    ch_SetStrptr(*this, str);
17381}
17382
17383// --- algo.Smallstr20.ch.Set
17384// Copy from same type
17385// Copy value from RHS.
17386inline void algo::Smallstr20::operator =(const algo::Smallstr20& parent) {
17387    memcpy(ch, parent.ch, parent.n_ch);
17388    n_ch = parent.n_ch;
17389}
17390
17391// --- algo.Smallstr20.ch.Ctor
17392inline  algo::Smallstr20::Smallstr20(const algo::Smallstr20 &rhs) {
17393    operator =(rhs);
17394}
17395
17396// --- algo.Smallstr20.ch.CtorStrptr
17397inline  algo::Smallstr20::Smallstr20(const algo::strptr &rhs) {
17398    ch_SetStrptr(*this, rhs);
17399}
17400
17401// --- algo.Smallstr20.ch.Cast
17402inline algo::Smallstr20::operator algo::strptr () const {
17403    return ch_Getary(*this);
17404}
17405
17406// --- algo.Smallstr20..Lt
17407inline bool algo::Smallstr20_Lt(algo::Smallstr20& lhs, algo::Smallstr20& rhs) {
17408    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
17409}
17410
17411// --- algo.Smallstr20..Cmp
17412inline i32 algo::Smallstr20_Cmp(algo::Smallstr20& lhs, algo::Smallstr20& rhs) {
17413    i32 retval = 0;
17414    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17415    return retval;
17416}
17417
17418// --- algo.Smallstr20..Init
17419// Set all fields to initial values.
17420inline void algo::Smallstr20_Init(algo::Smallstr20& parent) {
17421    parent.n_ch = 0;
17422}
17423
17424// --- algo.Smallstr20..Eq
17425inline bool algo::Smallstr20_Eq(algo::Smallstr20& lhs, algo::Smallstr20& rhs) {
17426    bool retval = true;
17427    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17428    return retval;
17429}
17430
17431// --- algo.Smallstr20..Update
17432// Set value. Return true if new value is different from old value.
17433inline bool algo::Smallstr20_Update(algo::Smallstr20 &lhs, algo::Smallstr20& rhs) {
17434    bool ret = !Smallstr20_Eq(lhs, rhs); // compare values
17435    if (ret) {
17436        lhs = rhs; // update
17437    }
17438    return ret;
17439}
17440
17441// --- algo.Smallstr20..EqStrptr
17442inline bool algo::Smallstr20_EqStrptr(const algo::Smallstr20& lhs, const algo::strptr& rhs) {
17443    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17444}
17445
17446inline bool algo::Smallstr200::operator ==(const algo::Smallstr200 &rhs) const {
17447    return algo::Smallstr200_Eq(const_cast<algo::Smallstr200&>(*this),const_cast<algo::Smallstr200&>(rhs));
17448}
17449
17450inline bool algo::Smallstr200::operator !=(const algo::Smallstr200 &rhs) const {
17451    return !algo::Smallstr200_Eq(const_cast<algo::Smallstr200&>(*this),const_cast<algo::Smallstr200&>(rhs));
17452}
17453
17454inline bool algo::Smallstr200::operator ==(const algo::strptr &rhs) const {
17455    return algo::Smallstr200_EqStrptr(const_cast<algo::Smallstr200&>(*this),rhs);
17456}
17457inline algo::Smallstr200::Smallstr200() {
17458    algo::Smallstr200_Init(*this);
17459}
17460
17461
17462// --- algo.Smallstr200.ch.Add
17463// Append character to string.
17464// If there is no space for an extra character, do nothing.
17465inline void algo::ch_Add(algo::Smallstr200& parent, char c) {
17466    if (parent.n_ch < 200) {
17467        parent.ch[parent.n_ch++] = c;
17468    }
17469}
17470
17471// --- algo.Smallstr200.ch.AddStrptr
17472// Append string to this string.
17473// If there is no space for an extra character, trim.
17474// If there is no space left, dump core in debug mode.
17475inline void algo::ch_AddStrptr(algo::Smallstr200& parent, algo::strptr str) {
17476    int n_new = str.n_elems;
17477    if (parent.n_ch + n_new > 200) {
17478        n_new = 200 - parent.n_ch;
17479    }
17480    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17481    parent.n_ch = u8(parent.n_ch + n_new);
17482}
17483
17484// --- algo.Smallstr200.ch.Getary
17485// Access string as array of chars
17486inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr200& parent) {
17487    int len = ch_N(parent);
17488    algo::aryptr<char> ret((char*)parent.ch, len);
17489    return ret;
17490}
17491
17492// --- algo.Smallstr200.ch.HashStrptr
17493inline u32 algo::Smallstr200_Hash(u32 prev, const algo::strptr &str) {
17494    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17495}
17496
17497// --- algo.Smallstr200.ch.Init
17498inline void algo::ch_Init(algo::Smallstr200 &parent) {
17499    parent.n_ch = 0;
17500}
17501
17502// --- algo.Smallstr200.ch.Max
17503// always return constant 200
17504inline int algo::ch_Max(algo::Smallstr200& parent) {
17505    (void)parent;
17506    return 200;
17507}
17508
17509// --- algo.Smallstr200.ch.N
17510inline int algo::ch_N(const algo::Smallstr200& parent) {
17511    u64 ret;
17512    ret = parent.n_ch;
17513    return int(ret);
17514}
17515
17516// --- algo.Smallstr200.ch.AssignStrptr
17517// Copy from strptr (operator=)
17518inline void algo::Smallstr200::operator =(const algo::strptr &str) {
17519    ch_SetStrptr(*this, str);
17520}
17521
17522// --- algo.Smallstr200.ch.Set
17523// Copy from same type
17524// Copy value from RHS.
17525inline void algo::Smallstr200::operator =(const algo::Smallstr200& parent) {
17526    memcpy(ch, parent.ch, parent.n_ch);
17527    n_ch = parent.n_ch;
17528}
17529
17530// --- algo.Smallstr200.ch.Ctor
17531inline  algo::Smallstr200::Smallstr200(const algo::Smallstr200 &rhs) {
17532    operator =(rhs);
17533}
17534
17535// --- algo.Smallstr200.ch.CtorStrptr
17536inline  algo::Smallstr200::Smallstr200(const algo::strptr &rhs) {
17537    ch_SetStrptr(*this, rhs);
17538}
17539
17540// --- algo.Smallstr200.ch.Cast
17541inline algo::Smallstr200::operator algo::strptr () const {
17542    return ch_Getary(*this);
17543}
17544
17545// --- algo.Smallstr200..Cmp
17546inline i32 algo::Smallstr200_Cmp(algo::Smallstr200& lhs, algo::Smallstr200& rhs) {
17547    i32 retval = 0;
17548    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17549    return retval;
17550}
17551
17552// --- algo.Smallstr200..Init
17553// Set all fields to initial values.
17554inline void algo::Smallstr200_Init(algo::Smallstr200& parent) {
17555    parent.n_ch = 0;
17556}
17557
17558// --- algo.Smallstr200..Eq
17559inline bool algo::Smallstr200_Eq(algo::Smallstr200& lhs, algo::Smallstr200& rhs) {
17560    bool retval = true;
17561    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17562    return retval;
17563}
17564
17565// --- algo.Smallstr200..EqStrptr
17566inline bool algo::Smallstr200_EqStrptr(const algo::Smallstr200& lhs, const algo::strptr& rhs) {
17567    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17568}
17569
17570inline bool algo::Smallstr25::operator ==(const algo::Smallstr25 &rhs) const {
17571    return algo::Smallstr25_Eq(const_cast<algo::Smallstr25&>(*this),const_cast<algo::Smallstr25&>(rhs));
17572}
17573
17574inline bool algo::Smallstr25::operator !=(const algo::Smallstr25 &rhs) const {
17575    return !algo::Smallstr25_Eq(const_cast<algo::Smallstr25&>(*this),const_cast<algo::Smallstr25&>(rhs));
17576}
17577
17578inline bool algo::Smallstr25::operator ==(const algo::strptr &rhs) const {
17579    return algo::Smallstr25_EqStrptr(const_cast<algo::Smallstr25&>(*this),rhs);
17580}
17581inline algo::Smallstr25::Smallstr25() {
17582    algo::Smallstr25_Init(*this);
17583}
17584
17585
17586// --- algo.Smallstr25.ch.Add
17587// Append character to string.
17588// If there is no space for an extra character, do nothing.
17589inline void algo::ch_Add(algo::Smallstr25& parent, char c) {
17590    if (parent.n_ch < 25) {
17591        parent.ch[parent.n_ch++] = c;
17592    }
17593}
17594
17595// --- algo.Smallstr25.ch.AddStrptr
17596// Append string to this string.
17597// If there is no space for an extra character, trim.
17598// If there is no space left, dump core in debug mode.
17599inline void algo::ch_AddStrptr(algo::Smallstr25& parent, algo::strptr str) {
17600    int n_new = str.n_elems;
17601    if (parent.n_ch + n_new > 25) {
17602        n_new = 25 - parent.n_ch;
17603    }
17604    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17605    parent.n_ch = u8(parent.n_ch + n_new);
17606}
17607
17608// --- algo.Smallstr25.ch.Getary
17609// Access string as array of chars
17610inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr25& parent) {
17611    int len = ch_N(parent);
17612    algo::aryptr<char> ret((char*)parent.ch, len);
17613    return ret;
17614}
17615
17616// --- algo.Smallstr25.ch.HashStrptr
17617inline u32 algo::Smallstr25_Hash(u32 prev, const algo::strptr &str) {
17618    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17619}
17620
17621// --- algo.Smallstr25.ch.Init
17622inline void algo::ch_Init(algo::Smallstr25 &parent) {
17623    parent.n_ch = 0;
17624}
17625
17626// --- algo.Smallstr25.ch.Max
17627// always return constant 25
17628inline int algo::ch_Max(algo::Smallstr25& parent) {
17629    (void)parent;
17630    return 25;
17631}
17632
17633// --- algo.Smallstr25.ch.N
17634inline int algo::ch_N(const algo::Smallstr25& parent) {
17635    u64 ret;
17636    ret = parent.n_ch;
17637    return int(ret);
17638}
17639
17640// --- algo.Smallstr25.ch.AssignStrptr
17641// Copy from strptr (operator=)
17642inline void algo::Smallstr25::operator =(const algo::strptr &str) {
17643    ch_SetStrptr(*this, str);
17644}
17645
17646// --- algo.Smallstr25.ch.Set
17647// Copy from same type
17648// Copy value from RHS.
17649inline void algo::Smallstr25::operator =(const algo::Smallstr25& parent) {
17650    memcpy(ch, parent.ch, parent.n_ch);
17651    n_ch = parent.n_ch;
17652}
17653
17654// --- algo.Smallstr25.ch.Ctor
17655inline  algo::Smallstr25::Smallstr25(const algo::Smallstr25 &rhs) {
17656    operator =(rhs);
17657}
17658
17659// --- algo.Smallstr25.ch.CtorStrptr
17660inline  algo::Smallstr25::Smallstr25(const algo::strptr &rhs) {
17661    ch_SetStrptr(*this, rhs);
17662}
17663
17664// --- algo.Smallstr25.ch.Cast
17665inline algo::Smallstr25::operator algo::strptr () const {
17666    return ch_Getary(*this);
17667}
17668
17669// --- algo.Smallstr25..Cmp
17670inline i32 algo::Smallstr25_Cmp(algo::Smallstr25& lhs, algo::Smallstr25& rhs) {
17671    i32 retval = 0;
17672    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17673    return retval;
17674}
17675
17676// --- algo.Smallstr25..Init
17677// Set all fields to initial values.
17678inline void algo::Smallstr25_Init(algo::Smallstr25& parent) {
17679    parent.n_ch = 0;
17680}
17681
17682// --- algo.Smallstr25..Eq
17683inline bool algo::Smallstr25_Eq(algo::Smallstr25& lhs, algo::Smallstr25& rhs) {
17684    bool retval = true;
17685    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17686    return retval;
17687}
17688
17689// --- algo.Smallstr25..EqStrptr
17690inline bool algo::Smallstr25_EqStrptr(const algo::Smallstr25& lhs, const algo::strptr& rhs) {
17691    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17692}
17693
17694inline bool algo::Smallstr3::operator ==(const algo::Smallstr3 &rhs) const {
17695    return algo::Smallstr3_Eq(const_cast<algo::Smallstr3&>(*this),const_cast<algo::Smallstr3&>(rhs));
17696}
17697
17698inline bool algo::Smallstr3::operator !=(const algo::Smallstr3 &rhs) const {
17699    return !algo::Smallstr3_Eq(const_cast<algo::Smallstr3&>(*this),const_cast<algo::Smallstr3&>(rhs));
17700}
17701
17702inline bool algo::Smallstr3::operator ==(const algo::strptr &rhs) const {
17703    return algo::Smallstr3_EqStrptr(const_cast<algo::Smallstr3&>(*this),rhs);
17704}
17705inline algo::Smallstr3::Smallstr3() {
17706    algo::Smallstr3_Init(*this);
17707}
17708
17709
17710// --- algo.Smallstr3.ch.Add
17711// Append character to string.
17712// If there is no space for an extra character, do nothing.
17713inline void algo::ch_Add(algo::Smallstr3& parent, char c) {
17714    if (parent.n_ch < 3) {
17715        parent.ch[parent.n_ch++] = c;
17716    }
17717}
17718
17719// --- algo.Smallstr3.ch.AddStrptr
17720// Append string to this string.
17721// If there is no space for an extra character, trim.
17722// If there is no space left, dump core in debug mode.
17723inline void algo::ch_AddStrptr(algo::Smallstr3& parent, algo::strptr str) {
17724    int n_new = str.n_elems;
17725    if (parent.n_ch + n_new > 3) {
17726        n_new = 3 - parent.n_ch;
17727    }
17728    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17729    parent.n_ch = u8(parent.n_ch + n_new);
17730}
17731
17732// --- algo.Smallstr3.ch.Getary
17733// Access string as array of chars
17734inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr3& parent) {
17735    int len = ch_N(parent);
17736    algo::aryptr<char> ret((char*)parent.ch, len);
17737    return ret;
17738}
17739
17740// --- algo.Smallstr3.ch.HashStrptr
17741inline u32 algo::Smallstr3_Hash(u32 prev, const algo::strptr &str) {
17742    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17743}
17744
17745// --- algo.Smallstr3.ch.Init
17746inline void algo::ch_Init(algo::Smallstr3 &parent) {
17747    parent.n_ch = 0;
17748}
17749
17750// --- algo.Smallstr3.ch.Max
17751// always return constant 3
17752inline int algo::ch_Max(algo::Smallstr3& parent) {
17753    (void)parent;
17754    return 3;
17755}
17756
17757// --- algo.Smallstr3.ch.N
17758inline int algo::ch_N(const algo::Smallstr3& parent) {
17759    u64 ret;
17760    ret = parent.n_ch;
17761    return int(ret);
17762}
17763
17764// --- algo.Smallstr3.ch.AssignStrptr
17765// Copy from strptr (operator=)
17766inline void algo::Smallstr3::operator =(const algo::strptr &str) {
17767    ch_SetStrptr(*this, str);
17768}
17769
17770// --- algo.Smallstr3.ch.Set
17771// Copy from same type
17772// Copy value from RHS.
17773inline void algo::Smallstr3::operator =(const algo::Smallstr3& parent) {
17774    memcpy(ch, parent.ch, parent.n_ch);
17775    n_ch = parent.n_ch;
17776}
17777
17778// --- algo.Smallstr3.ch.Ctor
17779inline  algo::Smallstr3::Smallstr3(const algo::Smallstr3 &rhs) {
17780    operator =(rhs);
17781}
17782
17783// --- algo.Smallstr3.ch.CtorStrptr
17784inline  algo::Smallstr3::Smallstr3(const algo::strptr &rhs) {
17785    ch_SetStrptr(*this, rhs);
17786}
17787
17788// --- algo.Smallstr3.ch.Cast
17789inline algo::Smallstr3::operator algo::strptr () const {
17790    return ch_Getary(*this);
17791}
17792
17793// --- algo.Smallstr3..Cmp
17794inline i32 algo::Smallstr3_Cmp(algo::Smallstr3& lhs, algo::Smallstr3& rhs) {
17795    i32 retval = 0;
17796    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17797    return retval;
17798}
17799
17800// --- algo.Smallstr3..Init
17801// Set all fields to initial values.
17802inline void algo::Smallstr3_Init(algo::Smallstr3& parent) {
17803    parent.n_ch = 0;
17804}
17805
17806// --- algo.Smallstr3..Eq
17807inline bool algo::Smallstr3_Eq(algo::Smallstr3& lhs, algo::Smallstr3& rhs) {
17808    bool retval = true;
17809    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17810    return retval;
17811}
17812
17813// --- algo.Smallstr3..EqStrptr
17814inline bool algo::Smallstr3_EqStrptr(const algo::Smallstr3& lhs, const algo::strptr& rhs) {
17815    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17816}
17817
17818inline bool algo::Smallstr30::operator ==(const algo::Smallstr30 &rhs) const {
17819    return algo::Smallstr30_Eq(const_cast<algo::Smallstr30&>(*this),const_cast<algo::Smallstr30&>(rhs));
17820}
17821
17822inline bool algo::Smallstr30::operator !=(const algo::Smallstr30 &rhs) const {
17823    return !algo::Smallstr30_Eq(const_cast<algo::Smallstr30&>(*this),const_cast<algo::Smallstr30&>(rhs));
17824}
17825
17826inline bool algo::Smallstr30::operator ==(const algo::strptr &rhs) const {
17827    return algo::Smallstr30_EqStrptr(const_cast<algo::Smallstr30&>(*this),rhs);
17828}
17829
17830inline bool algo::Smallstr30::operator <(const algo::Smallstr30 &rhs) const {
17831    return algo::Smallstr30_Lt(const_cast<algo::Smallstr30&>(*this),const_cast<algo::Smallstr30&>(rhs));
17832}
17833
17834inline bool algo::Smallstr30::operator >(const algo::Smallstr30 &rhs) const {
17835    return rhs < *this;
17836}
17837
17838inline bool algo::Smallstr30::operator <=(const algo::Smallstr30 &rhs) const {
17839    return !(rhs < *this);
17840}
17841
17842inline bool algo::Smallstr30::operator >=(const algo::Smallstr30 &rhs) const {
17843    return !(*this < rhs);
17844}
17845inline algo::Smallstr30::Smallstr30() {
17846    algo::Smallstr30_Init(*this);
17847}
17848
17849
17850// --- algo.Smallstr30.ch.Add
17851// Append character to string.
17852// If there is no space for an extra character, do nothing.
17853inline void algo::ch_Add(algo::Smallstr30& parent, char c) {
17854    if (parent.n_ch < 30) {
17855        parent.ch[parent.n_ch++] = c;
17856    }
17857}
17858
17859// --- algo.Smallstr30.ch.AddStrptr
17860// Append string to this string.
17861// If there is no space for an extra character, trim.
17862// If there is no space left, dump core in debug mode.
17863inline void algo::ch_AddStrptr(algo::Smallstr30& parent, algo::strptr str) {
17864    int n_new = str.n_elems;
17865    if (parent.n_ch + n_new > 30) {
17866        n_new = 30 - parent.n_ch;
17867    }
17868    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17869    parent.n_ch = u8(parent.n_ch + n_new);
17870}
17871
17872// --- algo.Smallstr30.ch.Getary
17873// Access string as array of chars
17874inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr30& parent) {
17875    int len = ch_N(parent);
17876    algo::aryptr<char> ret((char*)parent.ch, len);
17877    return ret;
17878}
17879
17880// --- algo.Smallstr30.ch.HashStrptr
17881inline u32 algo::Smallstr30_Hash(u32 prev, const algo::strptr &str) {
17882    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17883}
17884
17885// --- algo.Smallstr30.ch.Init
17886inline void algo::ch_Init(algo::Smallstr30 &parent) {
17887    parent.n_ch = 0;
17888}
17889
17890// --- algo.Smallstr30.ch.Max
17891// always return constant 30
17892inline int algo::ch_Max(algo::Smallstr30& parent) {
17893    (void)parent;
17894    return 30;
17895}
17896
17897// --- algo.Smallstr30.ch.N
17898inline int algo::ch_N(const algo::Smallstr30& parent) {
17899    u64 ret;
17900    ret = parent.n_ch;
17901    return int(ret);
17902}
17903
17904// --- algo.Smallstr30.ch.AssignStrptr
17905// Copy from strptr (operator=)
17906inline void algo::Smallstr30::operator =(const algo::strptr &str) {
17907    ch_SetStrptr(*this, str);
17908}
17909
17910// --- algo.Smallstr30.ch.Set
17911// Copy from same type
17912// Copy value from RHS.
17913inline void algo::Smallstr30::operator =(const algo::Smallstr30& parent) {
17914    memcpy(ch, parent.ch, parent.n_ch);
17915    n_ch = parent.n_ch;
17916}
17917
17918// --- algo.Smallstr30.ch.Ctor
17919inline  algo::Smallstr30::Smallstr30(const algo::Smallstr30 &rhs) {
17920    operator =(rhs);
17921}
17922
17923// --- algo.Smallstr30.ch.CtorStrptr
17924inline  algo::Smallstr30::Smallstr30(const algo::strptr &rhs) {
17925    ch_SetStrptr(*this, rhs);
17926}
17927
17928// --- algo.Smallstr30.ch.Cast
17929inline algo::Smallstr30::operator algo::strptr () const {
17930    return ch_Getary(*this);
17931}
17932
17933// --- algo.Smallstr30..Lt
17934inline bool algo::Smallstr30_Lt(algo::Smallstr30& lhs, algo::Smallstr30& rhs) {
17935    return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
17936}
17937
17938// --- algo.Smallstr30..Cmp
17939inline i32 algo::Smallstr30_Cmp(algo::Smallstr30& lhs, algo::Smallstr30& rhs) {
17940    i32 retval = 0;
17941    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17942    return retval;
17943}
17944
17945// --- algo.Smallstr30..Init
17946// Set all fields to initial values.
17947inline void algo::Smallstr30_Init(algo::Smallstr30& parent) {
17948    parent.n_ch = 0;
17949}
17950
17951// --- algo.Smallstr30..Eq
17952inline bool algo::Smallstr30_Eq(algo::Smallstr30& lhs, algo::Smallstr30& rhs) {
17953    bool retval = true;
17954    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17955    return retval;
17956}
17957
17958// --- algo.Smallstr30..Update
17959// Set value. Return true if new value is different from old value.
17960inline bool algo::Smallstr30_Update(algo::Smallstr30 &lhs, algo::Smallstr30& rhs) {
17961    bool ret = !Smallstr30_Eq(lhs, rhs); // compare values
17962    if (ret) {
17963        lhs = rhs; // update
17964    }
17965    return ret;
17966}
17967
17968// --- algo.Smallstr30..EqStrptr
17969inline bool algo::Smallstr30_EqStrptr(const algo::Smallstr30& lhs, const algo::strptr& rhs) {
17970    return algo::strptr_Eq(ch_Getary(lhs), rhs);
17971}
17972
17973inline bool algo::Smallstr32::operator ==(const algo::Smallstr32 &rhs) const {
17974    return algo::Smallstr32_Eq(const_cast<algo::Smallstr32&>(*this),const_cast<algo::Smallstr32&>(rhs));
17975}
17976
17977inline bool algo::Smallstr32::operator !=(const algo::Smallstr32 &rhs) const {
17978    return !algo::Smallstr32_Eq(const_cast<algo::Smallstr32&>(*this),const_cast<algo::Smallstr32&>(rhs));
17979}
17980
17981inline bool algo::Smallstr32::operator ==(const algo::strptr &rhs) const {
17982    return algo::Smallstr32_EqStrptr(const_cast<algo::Smallstr32&>(*this),rhs);
17983}
17984inline algo::Smallstr32::Smallstr32() {
17985    algo::Smallstr32_Init(*this);
17986}
17987
17988
17989// --- algo.Smallstr32.ch.Add
17990// Append character to string.
17991// If there is no space for an extra character, do nothing.
17992inline void algo::ch_Add(algo::Smallstr32& parent, char c) {
17993    if (parent.n_ch < 32) {
17994        parent.ch[parent.n_ch++] = c;
17995    }
17996}
17997
17998// --- algo.Smallstr32.ch.AddStrptr
17999// Append string to this string.
18000// If there is no space for an extra character, trim.
18001// If there is no space left, dump core in debug mode.
18002inline void algo::ch_AddStrptr(algo::Smallstr32& parent, algo::strptr str) {
18003    int n_new = str.n_elems;
18004    if (parent.n_ch + n_new > 32) {
18005        n_new = 32 - parent.n_ch;
18006    }
18007    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18008    parent.n_ch = u8(parent.n_ch + n_new);
18009}
18010
18011// --- algo.Smallstr32.ch.Getary
18012// Access string as array of chars
18013inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr32& parent) {
18014    int len = ch_N(parent);
18015    algo::aryptr<char> ret((char*)parent.ch, len);
18016    return ret;
18017}
18018
18019// --- algo.Smallstr32.ch.HashStrptr
18020inline u32 algo::Smallstr32_Hash(u32 prev, const algo::strptr &str) {
18021    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18022}
18023
18024// --- algo.Smallstr32.ch.Init
18025inline void algo::ch_Init(algo::Smallstr32 &parent) {
18026    parent.n_ch = 0;
18027}
18028
18029// --- algo.Smallstr32.ch.Max
18030// always return constant 32
18031inline int algo::ch_Max(algo::Smallstr32& parent) {
18032    (void)parent;
18033    return 32;
18034}
18035
18036// --- algo.Smallstr32.ch.N
18037inline int algo::ch_N(const algo::Smallstr32& parent) {
18038    u64 ret;
18039    ret = parent.n_ch;
18040    return int(ret);
18041}
18042
18043// --- algo.Smallstr32.ch.AssignStrptr
18044// Copy from strptr (operator=)
18045inline void algo::Smallstr32::operator =(const algo::strptr &str) {
18046    ch_SetStrptr(*this, str);
18047}
18048
18049// --- algo.Smallstr32.ch.Set
18050// Copy from same type
18051// Copy value from RHS.
18052inline void algo::Smallstr32::operator =(const algo::Smallstr32& parent) {
18053    memcpy(ch, parent.ch, parent.n_ch);
18054    n_ch = parent.n_ch;
18055}
18056
18057// --- algo.Smallstr32.ch.Ctor
18058inline  algo::Smallstr32::Smallstr32(const algo::Smallstr32 &rhs) {
18059    operator =(rhs);
18060}
18061
18062// --- algo.Smallstr32.ch.CtorStrptr
18063inline  algo::Smallstr32::Smallstr32(const algo::strptr &rhs) {
18064    ch_SetStrptr(*this, rhs);
18065}
18066
18067// --- algo.Smallstr32.ch.Cast
18068inline algo::Smallstr32::operator algo::strptr () const {
18069    return ch_Getary(*this);
18070}
18071
18072// --- algo.Smallstr32..Cmp
18073inline i32 algo::Smallstr32_Cmp(algo::Smallstr32& lhs, algo::Smallstr32& rhs) {
18074    i32 retval = 0;
18075    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18076    return retval;
18077}
18078
18079// --- algo.Smallstr32..Init
18080// Set all fields to initial values.
18081inline void algo::Smallstr32_Init(algo::Smallstr32& parent) {
18082    parent.n_ch = 0;
18083}
18084
18085// --- algo.Smallstr32..Eq
18086inline bool algo::Smallstr32_Eq(algo::Smallstr32& lhs, algo::Smallstr32& rhs) {
18087    bool retval = true;
18088    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18089    return retval;
18090}
18091
18092// --- algo.Smallstr32..EqStrptr
18093inline bool algo::Smallstr32_EqStrptr(const algo::Smallstr32& lhs, const algo::strptr& rhs) {
18094    return algo::strptr_Eq(ch_Getary(lhs), rhs);
18095}
18096
18097inline bool algo::Smallstr4::operator ==(const algo::Smallstr4 &rhs) const {
18098    return algo::Smallstr4_Eq(const_cast<algo::Smallstr4&>(*this),const_cast<algo::Smallstr4&>(rhs));
18099}
18100
18101inline bool algo::Smallstr4::operator !=(const algo::Smallstr4 &rhs) const {
18102    return !algo::Smallstr4_Eq(const_cast<algo::Smallstr4&>(*this),const_cast<algo::Smallstr4&>(rhs));
18103}
18104
18105inline bool algo::Smallstr4::operator ==(const algo::strptr &rhs) const {
18106    return algo::Smallstr4_EqStrptr(const_cast<algo::Smallstr4&>(*this),rhs);
18107}
18108inline algo::Smallstr4::Smallstr4() {
18109    algo::Smallstr4_Init(*this);
18110}
18111
18112
18113// --- algo.Smallstr4.ch.Add
18114// Append character to string.
18115// If there is no space for an extra character, do nothing.
18116inline void algo::ch_Add(algo::Smallstr4& parent, char c) {
18117    if (parent.n_ch < 4) {
18118        parent.ch[parent.n_ch++] = c;
18119    }
18120}
18121
18122// --- algo.Smallstr4.ch.AddStrptr
18123// Append string to this string.
18124// If there is no space for an extra character, trim.
18125// If there is no space left, dump core in debug mode.
18126inline void algo::ch_AddStrptr(algo::Smallstr4& parent, algo::strptr str) {
18127    int n_new = str.n_elems;
18128    if (parent.n_ch + n_new > 4) {
18129        n_new = 4 - parent.n_ch;
18130    }
18131    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18132    parent.n_ch = u8(parent.n_ch + n_new);
18133}
18134
18135// --- algo.Smallstr4.ch.Getary
18136// Access string as array of chars
18137inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr4& parent) {
18138    int len = ch_N(parent);
18139    algo::aryptr<char> ret((char*)parent.ch, len);
18140    return ret;
18141}
18142
18143// --- algo.Smallstr4.ch.HashStrptr
18144inline u32 algo::Smallstr4_Hash(u32 prev, const algo::strptr &str) {
18145    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18146}
18147
18148// --- algo.Smallstr4.ch.Init
18149inline void algo::ch_Init(algo::Smallstr4 &parent) {
18150    parent.n_ch = 0;
18151}
18152
18153// --- algo.Smallstr4.ch.Max
18154// always return constant 4
18155inline int algo::ch_Max(algo::Smallstr4& parent) {
18156    (void)parent;
18157    return 4;
18158}
18159
18160// --- algo.Smallstr4.ch.N
18161inline int algo::ch_N(const algo::Smallstr4& parent) {
18162    u64 ret;
18163    ret = parent.n_ch;
18164    return int(ret);
18165}
18166
18167// --- algo.Smallstr4.ch.AssignStrptr
18168// Copy from strptr (operator=)
18169inline void algo::Smallstr4::operator =(const algo::strptr &str) {
18170    ch_SetStrptr(*this, str);
18171}
18172
18173// --- algo.Smallstr4.ch.Set
18174// Copy from same type
18175// Copy value from RHS.
18176inline void algo::Smallstr4::operator =(const algo::Smallstr4& parent) {
18177    memcpy(ch, parent.ch, parent.n_ch);
18178    n_ch = parent.n_ch;
18179}
18180
18181// --- algo.Smallstr4.ch.Ctor
18182inline  algo::Smallstr4::Smallstr4(const algo::Smallstr4 &rhs) {
18183    operator =(rhs);
18184}
18185
18186// --- algo.Smallstr4.ch.CtorStrptr
18187inline  algo::Smallstr4::Smallstr4(const algo::strptr &rhs) {
18188    ch_SetStrptr(*this, rhs);
18189}
18190
18191// --- algo.Smallstr4.ch.Cast
18192inline algo::Smallstr4::operator algo::strptr () const {
18193    return ch_Getary(*this);
18194}
18195
18196// --- algo.Smallstr4..Cmp
18197inline i32 algo::Smallstr4_Cmp(algo::Smallstr4& lhs, algo::Smallstr4& rhs) {
18198    i32 retval = 0;
18199    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18200    return retval;
18201}
18202
18203// --- algo.Smallstr4..Init
18204// Set all fields to initial values.
18205inline void algo::Smallstr4_Init(algo::Smallstr4& parent) {
18206    parent.n_ch = 0;
18207}
18208
18209// --- algo.Smallstr4..Eq
18210inline bool algo::Smallstr4_Eq(algo::Smallstr4& lhs, algo::Smallstr4& rhs) {
18211    bool retval = true;
18212    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18213    return retval;
18214}
18215
18216// --- algo.Smallstr4..EqStrptr
18217inline bool algo::Smallstr4_EqStrptr(const algo::Smallstr4& lhs, const algo::strptr& rhs) {
18218    return algo::strptr_Eq(ch_Getary(lhs), rhs);
18219}
18220
18221inline bool algo::Smallstr40::operator ==(const algo::Smallstr40 &rhs) const {
18222    return algo::Smallstr40_Eq(const_cast<algo::Smallstr40&>(*this),const_cast<algo::Smallstr40&>(rhs));
18223}
18224
18225inline bool algo::Smallstr40::operator !=(const algo::Smallstr40 &rhs) const {
18226    return !algo::Smallstr40_Eq(const_cast<algo::Smallstr40&>(*this),const_cast<algo::Smallstr40&>(rhs));
18227}
18228
18229inline bool algo::Smallstr40::operator ==(const algo::strptr &rhs) const {
18230    return algo::Smallstr40_EqStrptr(const_cast<algo::Smallstr40&>(*this),rhs);
18231}
18232inline algo::Smallstr40::Smallstr40() {
18233    algo::Smallstr40_Init(*this);
18234}
18235
18236
18237// --- algo.Smallstr40.ch.Add
18238// Append character to string.
18239// If there is no space for an extra character, do nothing.
18240inline void algo::ch_Add(algo::Smallstr40& parent, char c) {
18241    if (parent.n_ch < 40) {
18242        parent.ch[parent.n_ch++] = c;
18243    }
18244}
18245
18246// --- algo.Smallstr40.ch.AddStrptr
18247// Append string to this string.
18248// If there is no space for an extra character, trim.
18249// If there is no space left, dump core in debug mode.
18250inline void algo::ch_AddStrptr(algo::Smallstr40& parent, algo::strptr str) {
18251    int n_new = str.n_elems;
18252    if (parent.n_ch + n_new > 40) {
18253        n_new = 40 - parent.n_ch;
18254    }
18255    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18256    parent.n_ch = u8(parent.n_ch + n_new);
18257}
18258
18259// --- algo.Smallstr40.ch.Getary
18260// Access string as array of chars
18261inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr40& parent) {
18262    int len = ch_N(parent);
18263    algo::aryptr<char> ret((char*)parent.ch, len);
18264    return ret;
18265}
18266
18267// --- algo.Smallstr40.ch.HashStrptr
18268inline u32 algo::Smallstr40_Hash(u32 prev, const algo::strptr &str) {
18269    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18270}
18271
18272// --- algo.Smallstr40.ch.Init
18273inline void algo::ch_Init(algo::Smallstr40 &parent) {
18274    parent.n_ch = 0;
18275}
18276
18277// --- algo.Smallstr40.ch.Max
18278// always return constant 40
18279inline int algo::ch_Max(algo::Smallstr40& parent) {
18280    (void)parent;
18281    return 40;
18282}
18283
18284// --- algo.Smallstr40.ch.N
18285inline int algo::ch_N(const algo::Smallstr40& parent) {
18286    u64 ret;
18287    ret = parent.n_ch;
18288    return int(ret);
18289}
18290
18291// --- algo.Smallstr40.ch.AssignStrptr
18292// Copy from strptr (operator=)
18293inline void algo::Smallstr40::operator =(const algo::strptr &str) {
18294    ch_SetStrptr(*this, str);
18295}
18296
18297// --- algo.Smallstr40.ch.Set
18298// Copy from same type
18299// Copy value from RHS.
18300inline void algo::Smallstr40::operator =(const algo::Smallstr40& parent) {
18301    memcpy(ch, parent.ch, parent.n_ch);
18302    n_ch = parent.n_ch;
18303}
18304
18305// --- algo.Smallstr40.ch.Ctor
18306inline  algo::Smallstr40::Smallstr40(const algo::Smallstr40 &rhs) {
18307    operator =(rhs);
18308}
18309
18310// --- algo.Smallstr40.ch.CtorStrptr
18311inline  algo::Smallstr40::Smallstr40(const algo::strptr &rhs) {
18312    ch_SetStrptr(*this, rhs);
18313}
18314
18315// --- algo.Smallstr40.ch.Cast
18316inline algo::Smallstr40::operator algo::strptr () const {
18317    return ch_Getary(*this);
18318}
18319
18320// --- algo.Smallstr40..Cmp
18321inline i32 algo::Smallstr40_Cmp(algo::Smallstr40& lhs, algo::Smallstr40& rhs) {
18322    i32 retval = 0;
18323    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18324    return retval;
18325}
18326
18327// --- algo.Smallstr40..Init
18328// Set all fields to initial values.
18329inline void algo::Smallstr40_Init(algo::Smallstr40& parent) {
18330    parent.n_ch = 0;
18331}
18332
18333// --- algo.Smallstr40..Eq
18334inline bool algo::Smallstr40_Eq(algo::Smallstr40& lhs, algo::Smallstr40& rhs) {
18335    bool retval = true;
18336    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18337    return retval;
18338}
18339
18340// --- algo.Smallstr40..EqStrptr
18341inline bool algo::Smallstr40_EqStrptr(const algo::Smallstr40& lhs, const algo::strptr& rhs) {
18342    return algo::strptr_Eq(ch_Getary(lhs), rhs);
18343}
18344
18345inline bool algo::Smallstr5::operator ==(const algo::Smallstr5 &rhs) const {
18346    return algo::Smallstr5_Eq(const_cast<algo::Smallstr5&>(*this),const_cast<algo::Smallstr5&>(rhs));
18347}
18348
18349inline bool algo::Smallstr5::operator !=(const algo::Smallstr5 &rhs) const {
18350    return !algo::Smallstr5_Eq(const_cast<algo::Smallstr5&>(*this),const_cast<algo::Smallstr5&>(rhs));
18351}
18352
18353inline bool algo::Smallstr5::operator ==(const algo::strptr &rhs) const {
18354    return algo::Smallstr5_EqStrptr(const_cast<algo::Smallstr5&>(*this),rhs);
18355}
18356inline algo::Smallstr5::Smallstr5() {
18357    algo::Smallstr5_Init(*this);
18358}
18359
18360
18361// --- algo.Smallstr5.ch.Add
18362// Append character to string.
18363// If there is no space for an extra character, do nothing.
18364inline void algo::ch_Add(algo::Smallstr5& parent, char c) {
18365    if (parent.n_ch < 5) {
18366        parent.ch[parent.n_ch++] = c;
18367    }
18368}
18369
18370// --- algo.Smallstr5.ch.AddStrptr
18371// Append string to this string.
18372// If there is no space for an extra character, trim.
18373// If there is no space left, dump core in debug mode.
18374inline void algo::ch_AddStrptr(algo::Smallstr5& parent, algo::strptr str) {
18375    int n_new = str.n_elems;
18376    if (parent.n_ch + n_new > 5) {
18377        n_new = 5 - parent.n_ch;
18378    }
18379    memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18380    parent.n_ch = u8(parent.n_ch + n_new);
18381}
18382
18383// --- algo.Smallstr5.ch.Getary
18384// Access string as array of chars
18385inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr5& parent) {
18386    int len = ch_N(parent);
18387    algo::aryptr<char> ret((char*)parent.ch, len);
18388    return ret;
18389}
18390
18391// --- algo.Smallstr5.ch.HashStrptr
18392inline u32 algo::Smallstr5_Hash(u32 prev, const algo::strptr &str) {
18393    return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18394}
18395
18396// --- algo.Smallstr5.ch.Init
18397inline void algo::ch_Init(algo::Smallstr5 &parent) {
18398    parent.n_ch = 0;
18399}
18400
18401// --- algo.Smallstr5.ch.Max
18402// always return constant 5
18403inline int algo::ch_Max(algo::Smallstr5& parent) {
18404    (void)parent;
18405    return 5;
18406}
18407
18408// --- algo.Smallstr5.ch.N
18409inline int algo::ch_N(const algo::Smallstr5& parent) {
18410    u64 ret;
18411    ret = parent.n_ch;
18412    return int(ret);
18413}
18414
18415// --- algo.Smallstr5.ch.AssignStrptr
18416// Copy from strptr (operator=)
18417inline void algo::Smallstr5::operator =(const algo::strptr &str) {
18418    ch_SetStrptr(*this, str);
18419}
18420
18421// --- algo.Smallstr5.ch.Set
18422// Copy from same type
18423// Copy value from RHS.
18424inline void algo::Smallstr5::operator =(const algo::Smallstr5& parent) {
18425    memcpy(ch, parent.ch, parent.n_ch);
18426    n_ch = parent.n_ch;
18427}
18428
18429// --- algo.Smallstr5.ch.Ctor
18430inline  algo::Smallstr5::Smallstr5(const algo::Smallstr5 &rhs) {
18431    operator =(rhs);
18432}
18433
18434// --- algo.Smallstr5.ch.CtorStrptr
18435inline  algo::Smallstr5::Smallstr5(const algo::strptr &rhs) {
18436    ch_SetStrptr(*this, rhs);
18437}
18438
18439// --- algo.Smallstr5.ch.Cast
18440inline algo::Smallstr5::operator algo::strptr () const {
18441    return ch_Getary(*this);
18442}
18443
18444// --- algo.Smallstr5..Cmp
18445inline i32 algo::Smallstr5_Cmp(algo::Smallstr5& lhs, algo::Smallstr5& rhs) {
18446    i32 retval = 0;
18447    retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18448    return retval;
18449}
18450
18451// --- algo.Smallstr5..Init
18452// Set all fields to initial values.
18453inline void algo::Smallstr5_Init(algo::Smallstr5& parent) {
18454    parent.n_ch = 0;
18455}
18456
18457// --- algo.Smallstr5..Eq
18458inline bool algo::Smallstr5_Eq(algo::Smallstr5& lhs, algo::Smallstr5& rhs) {
18459    bool retval = true;
18460    retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18461    return retval;
18462}
18463
18464// --- algo.Smallstr5..EqStrptr
18465inline bool algo::Smallstr5_EqStrptr(const algo::Smallstr5& lhs, const algo::strptr& rhs) {
18466    return algo::strptr_Eq(ch_Getary(lhs), rhs);
18467}
18468inline algo::StringAry::StringAry() {
18469    algo::StringAry_Init(*this);
18470}
18471
18472inline algo::StringAry::~StringAry() {
18473    algo::StringAry_Uninit(*this);
18474}
18475
18476
18477// --- algo.StringAry.ary.EmptyQ
18478// Return true if index is empty
18479inline bool algo::ary_EmptyQ(algo::StringAry& parent) {
18480    return parent.ary_n == 0;
18481}
18482
18483// --- algo.StringAry.ary.Find
18484// Look up row by row id. Return NULL if out of range
18485inline algo::cstring* algo::ary_Find(algo::StringAry& parent, u64 t) {
18486    u64 idx = t;
18487    u64 lim = parent.ary_n;
18488    if (idx >= lim) return NULL;
18489    return parent.ary_elems + idx;
18490}
18491
18492// --- algo.StringAry.ary.Getary
18493// Return array pointer by value
18494inline algo::aryptr<algo::cstring> algo::ary_Getary(const algo::StringAry& parent) {
18495    return algo::aryptr<algo::cstring>(parent.ary_elems, parent.ary_n);
18496}
18497
18498// --- algo.StringAry.ary.Last
18499// Return pointer to last element of array, or NULL if array is empty
18500inline algo::cstring* algo::ary_Last(algo::StringAry& parent) {
18501    return ary_Find(parent, u64(parent.ary_n-1));
18502}
18503
18504// --- algo.StringAry.ary.Max
18505// Return max. number of items in the array
18506inline i32 algo::ary_Max(algo::StringAry& parent) {
18507    (void)parent;
18508    return parent.ary_max;
18509}
18510
18511// --- algo.StringAry.ary.N
18512// Return number of items in the array
18513inline i32 algo::ary_N(const algo::StringAry& parent) {
18514    return parent.ary_n;
18515}
18516
18517// --- algo.StringAry.ary.Reserve
18518// Make sure N *more* elements will fit in array. Process dies if out of memory
18519inline void algo::ary_Reserve(algo::StringAry& parent, int n) {
18520    u32 new_n = parent.ary_n + n;
18521    if (UNLIKELY(new_n > parent.ary_max)) {
18522        ary_AbsReserve(parent, new_n);
18523    }
18524}
18525
18526// --- algo.StringAry.ary.qFind
18527// 'quick' Access row by row id. No bounds checking.
18528inline algo::cstring& algo::ary_qFind(algo::StringAry& parent, u64 t) {
18529    return parent.ary_elems[t];
18530}
18531
18532// --- algo.StringAry.ary.qLast
18533// Return reference to last element of array. No bounds checking
18534inline algo::cstring& algo::ary_qLast(algo::StringAry& parent) {
18535    return ary_qFind(parent, u64(parent.ary_n-1));
18536}
18537
18538// --- algo.StringAry.ary.rowid_Get
18539// Return row id of specified element
18540inline u64 algo::ary_rowid_Get(algo::StringAry& parent, algo::cstring &elem) {
18541    u64 id = &elem - parent.ary_elems;
18542    return u64(id);
18543}
18544
18545// --- algo.StringAry.ary_curs.Next
18546// proceed to next item
18547inline void algo::StringAry_ary_curs_Next(StringAry_ary_curs &curs) {
18548    curs.index++;
18549}
18550
18551// --- algo.StringAry.ary_curs.Reset
18552inline void algo::StringAry_ary_curs_Reset(StringAry_ary_curs &curs, algo::StringAry &parent) {
18553    curs.elems = parent.ary_elems;
18554    curs.n_elems = parent.ary_n;
18555    curs.index = 0;
18556}
18557
18558// --- algo.StringAry.ary_curs.ValidQ
18559// cursor points to valid item
18560inline bool algo::StringAry_ary_curs_ValidQ(StringAry_ary_curs &curs) {
18561    return curs.index < curs.n_elems;
18562}
18563
18564// --- algo.StringAry.ary_curs.Access
18565// item access
18566inline algo::cstring& algo::StringAry_ary_curs_Access(StringAry_ary_curs &curs) {
18567    return curs.elems[curs.index];
18568}
18569
18570// --- algo.StringAry..Init
18571// Set all fields to initial values.
18572inline void algo::StringAry_Init(algo::StringAry& parent) {
18573    parent.ary_elems 	= 0; // (algo.StringAry.ary)
18574    parent.ary_n     	= 0; // (algo.StringAry.ary)
18575    parent.ary_max   	= 0; // (algo.StringAry.ary)
18576}
18577inline algo::TermStyle::TermStyle(u32                            in_value)
18578    : value(in_value)
18579{
18580}
18581inline algo::TermStyle::TermStyle(algo_TermStyleEnum arg) { this->value = u32(arg); }
18582inline algo::TermStyle::TermStyle() {
18583    algo::TermStyle_Init(*this);
18584}
18585
18586
18587// --- algo.TermStyle.value.GetEnum
18588// Get value of field as enum type
18589inline algo_TermStyleEnum algo::value_GetEnum(const algo::TermStyle& parent) {
18590    return algo_TermStyleEnum(parent.value);
18591}
18592
18593// --- algo.TermStyle.value.SetEnum
18594// Set value of field from enum type.
18595inline void algo::value_SetEnum(algo::TermStyle& parent, algo_TermStyleEnum rhs) {
18596    parent.value = u32(rhs);
18597}
18598
18599// --- algo.TermStyle.value.Cast
18600inline algo::TermStyle::operator algo_TermStyleEnum () const {
18601    return algo_TermStyleEnum((*this).value);
18602}
18603
18604// --- algo.TermStyle..Init
18605// Set all fields to initial values.
18606inline void algo::TermStyle_Init(algo::TermStyle& parent) {
18607    parent.value = u32(0);
18608}
18609inline algo::TextJust::TextJust(i32                            in_value)
18610    : value(in_value)
18611{
18612}
18613inline algo::TextJust::TextJust(algo_TextJustEnum arg) { this->value = i32(arg); }
18614inline algo::TextJust::TextJust() {
18615    algo::TextJust_Init(*this);
18616}
18617
18618
18619// --- algo.TextJust.value.GetEnum
18620// Get value of field as enum type
18621inline algo_TextJustEnum algo::value_GetEnum(const algo::TextJust& parent) {
18622    return algo_TextJustEnum(parent.value);
18623}
18624
18625// --- algo.TextJust.value.SetEnum
18626// Set value of field from enum type.
18627inline void algo::value_SetEnum(algo::TextJust& parent, algo_TextJustEnum rhs) {
18628    parent.value = i32(rhs);
18629}
18630
18631// --- algo.TextJust.value.Cast
18632inline algo::TextJust::operator algo_TextJustEnum () const {
18633    return algo_TextJustEnum((*this).value);
18634}
18635
18636// --- algo.TextJust..Init
18637// Set all fields to initial values.
18638inline void algo::TextJust_Init(algo::TextJust& parent) {
18639    parent.value = i32(0);
18640}
18641inline algo::TstampCache::TstampCache() {
18642    algo::TstampCache_Init(*this);
18643}
18644
18645inline algo::Tuple::Tuple() {
18646    algo::Tuple_Init(*this);
18647}
18648
18649inline algo::Tuple::~Tuple() {
18650    algo::Tuple_Uninit(*this);
18651}
18652
18653
18654// --- algo.Tuple.attrs.EmptyQ
18655// Return true if index is empty
18656inline bool algo::attrs_EmptyQ(algo::Tuple& parent) {
18657    return parent.attrs_n == 0;
18658}
18659
18660// --- algo.Tuple.attrs.Find
18661// Look up row by row id. Return NULL if out of range
18662inline algo::Attr* algo::attrs_Find(algo::Tuple& parent, u64 t) {
18663    u64 idx = t;
18664    u64 lim = parent.attrs_n;
18665    if (idx >= lim) return NULL;
18666    return parent.attrs_elems + idx;
18667}
18668
18669// --- algo.Tuple.attrs.Getary
18670// Return array pointer by value
18671inline algo::aryptr<algo::Attr> algo::attrs_Getary(const algo::Tuple& parent) {
18672    return algo::aryptr<algo::Attr>(parent.attrs_elems, parent.attrs_n);
18673}
18674
18675// --- algo.Tuple.attrs.Last
18676// Return pointer to last element of array, or NULL if array is empty
18677inline algo::Attr* algo::attrs_Last(algo::Tuple& parent) {
18678    return attrs_Find(parent, u64(parent.attrs_n-1));
18679}
18680
18681// --- algo.Tuple.attrs.Max
18682// Return max. number of items in the array
18683inline i32 algo::attrs_Max(algo::Tuple& parent) {
18684    (void)parent;
18685    return parent.attrs_max;
18686}
18687
18688// --- algo.Tuple.attrs.N
18689// Return number of items in the array
18690inline i32 algo::attrs_N(const algo::Tuple& parent) {
18691    return parent.attrs_n;
18692}
18693
18694// --- algo.Tuple.attrs.Reserve
18695// Make sure N *more* elements will fit in array. Process dies if out of memory
18696inline void algo::attrs_Reserve(algo::Tuple& parent, int n) {
18697    u32 new_n = parent.attrs_n + n;
18698    if (UNLIKELY(new_n > parent.attrs_max)) {
18699        attrs_AbsReserve(parent, new_n);
18700    }
18701}
18702
18703// --- algo.Tuple.attrs.qFind
18704// 'quick' Access row by row id. No bounds checking.
18705inline algo::Attr& algo::attrs_qFind(algo::Tuple& parent, u64 t) {
18706    return parent.attrs_elems[t];
18707}
18708
18709// --- algo.Tuple.attrs.qLast
18710// Return reference to last element of array. No bounds checking
18711inline algo::Attr& algo::attrs_qLast(algo::Tuple& parent) {
18712    return attrs_qFind(parent, u64(parent.attrs_n-1));
18713}
18714
18715// --- algo.Tuple.attrs.rowid_Get
18716// Return row id of specified element
18717inline u64 algo::attrs_rowid_Get(algo::Tuple& parent, algo::Attr &elem) {
18718    u64 id = &elem - parent.attrs_elems;
18719    return u64(id);
18720}
18721
18722// --- algo.Tuple.attrs_curs.Next
18723// proceed to next item
18724inline void algo::Tuple_attrs_curs_Next(Tuple_attrs_curs &curs) {
18725    curs.index++;
18726}
18727
18728// --- algo.Tuple.attrs_curs.Reset
18729inline void algo::Tuple_attrs_curs_Reset(Tuple_attrs_curs &curs, algo::Tuple &parent) {
18730    curs.elems = parent.attrs_elems;
18731    curs.n_elems = parent.attrs_n;
18732    curs.index = 0;
18733}
18734
18735// --- algo.Tuple.attrs_curs.ValidQ
18736// cursor points to valid item
18737inline bool algo::Tuple_attrs_curs_ValidQ(Tuple_attrs_curs &curs) {
18738    return curs.index < curs.n_elems;
18739}
18740
18741// --- algo.Tuple.attrs_curs.Access
18742// item access
18743inline algo::Attr& algo::Tuple_attrs_curs_Access(Tuple_attrs_curs &curs) {
18744    return curs.elems[curs.index];
18745}
18746
18747// --- algo.Tuple..Init
18748// Set all fields to initial values.
18749inline void algo::Tuple_Init(algo::Tuple& parent) {
18750    parent.attrs_elems 	= 0; // (algo.Tuple.attrs)
18751    parent.attrs_n     	= 0; // (algo.Tuple.attrs)
18752    parent.attrs_max   	= 0; // (algo.Tuple.attrs)
18753}
18754inline algo::U16Dec2::U16Dec2(u16                            in_value)
18755    : value(in_value)
18756{
18757}
18758inline algo::U16Dec2::U16Dec2() {
18759    algo::U16Dec2_Init(*this);
18760}
18761
18762
18763// --- algo.U16Dec2.value.qSetDouble
18764// Set value of field value.
18765// The value is rounded to the nearest integer.
18766// This ensures that truncation of a near-integer value does not occur.
18767// Example: 1.3 cannot be represented exactly as a double, the actual
18768// stored value will be 1.29999999. when we apply C truncation,
18769// we want to end up with 1.3, not 1.2.
18770inline void algo::value_qSetDouble(algo::U16Dec2& parent, double val) {
18771    double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
18772    // set underlying field.
18773    parent.value = intval;
18774}
18775
18776// --- algo.U16Dec2.value.GetDouble
18777inline double algo::value_GetDouble(const algo::U16Dec2& parent) {
18778    double ret;
18779    ret = parent.value / double(100);
18780    return ret;
18781}
18782
18783// --- algo.U16Dec2.value.GetInt
18784// Return integer portion (divide number by 100)
18785inline u16 algo::value_GetInt(const algo::U16Dec2& parent) {
18786    u16 ret;
18787    ret = parent.value / 100;
18788    return ret;
18789}
18790
18791// --- algo.U16Dec2.value.GetScale
18792// Return constant 100
18793inline u16 algo::U16Dec2_GetScale() {
18794    return 100;
18795}
18796
18797// --- algo.U16Dec2.value.Cast
18798inline algo::U16Dec2::operator u16 () const {
18799    return u16((*this).value);
18800}
18801
18802// --- algo.U16Dec2..Hash
18803inline u32 algo::U16Dec2_Hash(u32 prev, algo::U16Dec2 rhs) {
18804    prev = u16_Hash(prev, rhs.value);
18805    return prev;
18806}
18807
18808// --- algo.U16Dec2..Init
18809// Set all fields to initial values.
18810inline void algo::U16Dec2_Init(algo::U16Dec2& parent) {
18811    parent.value = u16(0);
18812}
18813inline algo::U32Dec1::U32Dec1(u32                            in_value)
18814    : value(in_value)
18815{
18816}
18817inline algo::U32Dec1::U32Dec1() {
18818    algo::U32Dec1_Init(*this);
18819}
18820
18821
18822// --- algo.U32Dec1.value.qSetDouble
18823// Set value of field value.
18824// The value is rounded to the nearest integer.
18825// This ensures that truncation of a near-integer value does not occur.
18826// Example: 1.3 cannot be represented exactly as a double, the actual
18827// stored value will be 1.29999999. when we apply C truncation,
18828// we want to end up with 1.3, not 1.2.
18829inline void algo::value_qSetDouble(algo::U32Dec1& parent, double val) {
18830    double intval = val * 10 + (val > 0 ? 0.5 : -0.5);
18831    // set underlying field.
18832    parent.value = intval;
18833}
18834
18835// --- algo.U32Dec1.value.GetDouble
18836inline double algo::value_GetDouble(const algo::U32Dec1& parent) {
18837    double ret;
18838    ret = parent.value / double(10);
18839    return ret;
18840}
18841
18842// --- algo.U32Dec1.value.GetInt
18843// Return integer portion (divide number by 10)
18844inline u32 algo::value_GetInt(const algo::U32Dec1& parent) {
18845    u32 ret;
18846    ret = parent.value / 10;
18847    return ret;
18848}
18849
18850// --- algo.U32Dec1.value.GetScale
18851// Return constant 10
18852inline u32 algo::U32Dec1_GetScale() {
18853    return 10;
18854}
18855
18856// --- algo.U32Dec1.value.Cast
18857inline algo::U32Dec1::operator u32 () const {
18858    return u32((*this).value);
18859}
18860
18861// --- algo.U32Dec1..Hash
18862inline u32 algo::U32Dec1_Hash(u32 prev, algo::U32Dec1 rhs) {
18863    prev = u32_Hash(prev, rhs.value);
18864    return prev;
18865}
18866
18867// --- algo.U32Dec1..Init
18868// Set all fields to initial values.
18869inline void algo::U32Dec1_Init(algo::U32Dec1& parent) {
18870    parent.value = u32(0);
18871}
18872inline algo::U32Dec2::U32Dec2(u32                            in_value)
18873    : value(in_value)
18874{
18875}
18876inline algo::U32Dec2::U32Dec2() {
18877    algo::U32Dec2_Init(*this);
18878}
18879
18880
18881// --- algo.U32Dec2.value.qSetDouble
18882// Set value of field value.
18883// The value is rounded to the nearest integer.
18884// This ensures that truncation of a near-integer value does not occur.
18885// Example: 1.3 cannot be represented exactly as a double, the actual
18886// stored value will be 1.29999999. when we apply C truncation,
18887// we want to end up with 1.3, not 1.2.
18888inline void algo::value_qSetDouble(algo::U32Dec2& parent, double val) {
18889    double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
18890    // set underlying field.
18891    parent.value = intval;
18892}
18893
18894// --- algo.U32Dec2.value.GetDouble
18895inline double algo::value_GetDouble(const algo::U32Dec2& parent) {
18896    double ret;
18897    ret = parent.value / double(100);
18898    return ret;
18899}
18900
18901// --- algo.U32Dec2.value.GetInt
18902// Return integer portion (divide number by 100)
18903inline u32 algo::value_GetInt(const algo::U32Dec2& parent) {
18904    u32 ret;
18905    ret = parent.value / 100;
18906    return ret;
18907}
18908
18909// --- algo.U32Dec2.value.GetScale
18910// Return constant 100
18911inline u32 algo::U32Dec2_GetScale() {
18912    return 100;
18913}
18914
18915// --- algo.U32Dec2.value.Cast
18916inline algo::U32Dec2::operator u32 () const {
18917    return u32((*this).value);
18918}
18919
18920// --- algo.U32Dec2..Hash
18921inline u32 algo::U32Dec2_Hash(u32 prev, algo::U32Dec2 rhs) {
18922    prev = u32_Hash(prev, rhs.value);
18923    return prev;
18924}
18925
18926// --- algo.U32Dec2..Init
18927// Set all fields to initial values.
18928inline void algo::U32Dec2_Init(algo::U32Dec2& parent) {
18929    parent.value = u32(0);
18930}
18931inline algo::U32Dec3::U32Dec3(u32                            in_value)
18932    : value(in_value)
18933{
18934}
18935inline algo::U32Dec3::U32Dec3() {
18936    algo::U32Dec3_Init(*this);
18937}
18938
18939
18940// --- algo.U32Dec3.value.qSetDouble
18941// Set value of field value.
18942// The value is rounded to the nearest integer.
18943// This ensures that truncation of a near-integer value does not occur.
18944// Example: 1.3 cannot be represented exactly as a double, the actual
18945// stored value will be 1.29999999. when we apply C truncation,
18946// we want to end up with 1.3, not 1.2.
18947inline void algo::value_qSetDouble(algo::U32Dec3& parent, double val) {
18948    double intval = val * 1000 + (val > 0 ? 0.5 : -0.5);
18949    // set underlying field.
18950    parent.value = intval;
18951}
18952
18953// --- algo.U32Dec3.value.GetDouble
18954inline double algo::value_GetDouble(const algo::U32Dec3& parent) {
18955    double ret;
18956    ret = parent.value / double(1000);
18957    return ret;
18958}
18959
18960// --- algo.U32Dec3.value.GetInt
18961// Return integer portion (divide number by 1000)
18962inline u32 algo::value_GetInt(const algo::U32Dec3& parent) {
18963    u32 ret;
18964    ret = parent.value / 1000;
18965    return ret;
18966}
18967
18968// --- algo.U32Dec3.value.GetScale
18969// Return constant 1000
18970inline u32 algo::U32Dec3_GetScale() {
18971    return 1000;
18972}
18973
18974// --- algo.U32Dec3.value.Cast
18975inline algo::U32Dec3::operator u32 () const {
18976    return u32((*this).value);
18977}
18978
18979// --- algo.U32Dec3..Hash
18980inline u32 algo::U32Dec3_Hash(u32 prev, algo::U32Dec3 rhs) {
18981    prev = u32_Hash(prev, rhs.value);
18982    return prev;
18983}
18984
18985// --- algo.U32Dec3..Init
18986// Set all fields to initial values.
18987inline void algo::U32Dec3_Init(algo::U32Dec3& parent) {
18988    parent.value = u32(0);
18989}
18990inline algo::U32Dec4::U32Dec4(u32                            in_value)
18991    : value(in_value)
18992{
18993}
18994inline algo::U32Dec4::U32Dec4() {
18995    algo::U32Dec4_Init(*this);
18996}
18997
18998
18999// --- algo.U32Dec4.value.qSetDouble
19000// Set value of field value.
19001// The value is rounded to the nearest integer.
19002// This ensures that truncation of a near-integer value does not occur.
19003// Example: 1.3 cannot be represented exactly as a double, the actual
19004// stored value will be 1.29999999. when we apply C truncation,
19005// we want to end up with 1.3, not 1.2.
19006inline void algo::value_qSetDouble(algo::U32Dec4& parent, double val) {
19007    double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
19008    // set underlying field.
19009    parent.value = intval;
19010}
19011
19012// --- algo.U32Dec4.value.GetDouble
19013inline double algo::value_GetDouble(const algo::U32Dec4& parent) {
19014    double ret;
19015    ret = parent.value / double(10000);
19016    return ret;
19017}
19018
19019// --- algo.U32Dec4.value.GetInt
19020// Return integer portion (divide number by 10000)
19021inline u32 algo::value_GetInt(const algo::U32Dec4& parent) {
19022    u32 ret;
19023    ret = parent.value / 10000;
19024    return ret;
19025}
19026
19027// --- algo.U32Dec4.value.GetScale
19028// Return constant 10000
19029inline u32 algo::U32Dec4_GetScale() {
19030    return 10000;
19031}
19032
19033// --- algo.U32Dec4.value.Cast
19034inline algo::U32Dec4::operator u32 () const {
19035    return u32((*this).value);
19036}
19037
19038// --- algo.U32Dec4..Hash
19039inline u32 algo::U32Dec4_Hash(u32 prev, algo::U32Dec4 rhs) {
19040    prev = u32_Hash(prev, rhs.value);
19041    return prev;
19042}
19043
19044// --- algo.U32Dec4..Init
19045// Set all fields to initial values.
19046inline void algo::U32Dec4_Init(algo::U32Dec4& parent) {
19047    parent.value = u32(0);
19048}
19049inline algo::U32Dec5::U32Dec5(u32                            in_value)
19050    : value(in_value)
19051{
19052}
19053inline algo::U32Dec5::U32Dec5() {
19054    algo::U32Dec5_Init(*this);
19055}
19056
19057
19058// --- algo.U32Dec5.value.qSetDouble
19059// Set value of field value.
19060// The value is rounded to the nearest integer.
19061// This ensures that truncation of a near-integer value does not occur.
19062// Example: 1.3 cannot be represented exactly as a double, the actual
19063// stored value will be 1.29999999. when we apply C truncation,
19064// we want to end up with 1.3, not 1.2.
19065inline void algo::value_qSetDouble(algo::U32Dec5& parent, double val) {
19066    double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
19067    // set underlying field.
19068    parent.value = intval;
19069}
19070
19071// --- algo.U32Dec5.value.GetDouble
19072inline double algo::value_GetDouble(const algo::U32Dec5& parent) {
19073    double ret;
19074    ret = parent.value / double(100000);
19075    return ret;
19076}
19077
19078// --- algo.U32Dec5.value.GetInt
19079// Return integer portion (divide number by 100000)
19080inline u32 algo::value_GetInt(const algo::U32Dec5& parent) {
19081    u32 ret;
19082    ret = parent.value / 100000;
19083    return ret;
19084}
19085
19086// --- algo.U32Dec5.value.GetScale
19087// Return constant 100000
19088inline u32 algo::U32Dec5_GetScale() {
19089    return 100000;
19090}
19091
19092// --- algo.U32Dec5.value.Cast
19093inline algo::U32Dec5::operator u32 () const {
19094    return u32((*this).value);
19095}
19096
19097// --- algo.U32Dec5..Hash
19098inline u32 algo::U32Dec5_Hash(u32 prev, algo::U32Dec5 rhs) {
19099    prev = u32_Hash(prev, rhs.value);
19100    return prev;
19101}
19102
19103// --- algo.U32Dec5..Init
19104// Set all fields to initial values.
19105inline void algo::U32Dec5_Init(algo::U32Dec5& parent) {
19106    parent.value = u32(0);
19107}
19108inline algo::U64Ary::U64Ary() {
19109    algo::U64Ary_Init(*this);
19110}
19111
19112inline algo::U64Ary::~U64Ary() {
19113    algo::U64Ary_Uninit(*this);
19114}
19115
19116
19117// --- algo.U64Ary.ary.EmptyQ
19118// Return true if index is empty
19119inline bool algo::ary_EmptyQ(algo::U64Ary& parent) {
19120    return parent.ary_n == 0;
19121}
19122
19123// --- algo.U64Ary.ary.Find
19124// Look up row by row id. Return NULL if out of range
19125inline u64* algo::ary_Find(algo::U64Ary& parent, u64 t) {
19126    u64 idx = t;
19127    u64 lim = parent.ary_n;
19128    if (idx >= lim) return NULL;
19129    return parent.ary_elems + idx;
19130}
19131
19132// --- algo.U64Ary.ary.Getary
19133// Return array pointer by value
19134inline algo::aryptr<u64> algo::ary_Getary(const algo::U64Ary& parent) {
19135    return algo::aryptr<u64>(parent.ary_elems, parent.ary_n);
19136}
19137
19138// --- algo.U64Ary.ary.Last
19139// Return pointer to last element of array, or NULL if array is empty
19140inline u64* algo::ary_Last(algo::U64Ary& parent) {
19141    return ary_Find(parent, u64(parent.ary_n-1));
19142}
19143
19144// --- algo.U64Ary.ary.Max
19145// Return max. number of items in the array
19146inline i32 algo::ary_Max(algo::U64Ary& parent) {
19147    (void)parent;
19148    return parent.ary_max;
19149}
19150
19151// --- algo.U64Ary.ary.N
19152// Return number of items in the array
19153inline i32 algo::ary_N(const algo::U64Ary& parent) {
19154    return parent.ary_n;
19155}
19156
19157// --- algo.U64Ary.ary.RemoveAll
19158inline void algo::ary_RemoveAll(algo::U64Ary& parent) {
19159    parent.ary_n = 0;
19160}
19161
19162// --- algo.U64Ary.ary.Reserve
19163// Make sure N *more* elements will fit in array. Process dies if out of memory
19164inline void algo::ary_Reserve(algo::U64Ary& parent, int n) {
19165    u32 new_n = parent.ary_n + n;
19166    if (UNLIKELY(new_n > parent.ary_max)) {
19167        ary_AbsReserve(parent, new_n);
19168    }
19169}
19170
19171// --- algo.U64Ary.ary.qFind
19172// 'quick' Access row by row id. No bounds checking.
19173inline u64& algo::ary_qFind(algo::U64Ary& parent, u64 t) {
19174    return parent.ary_elems[t];
19175}
19176
19177// --- algo.U64Ary.ary.qLast
19178// Return reference to last element of array. No bounds checking
19179inline u64& algo::ary_qLast(algo::U64Ary& parent) {
19180    return ary_qFind(parent, u64(parent.ary_n-1));
19181}
19182
19183// --- algo.U64Ary.ary.rowid_Get
19184// Return row id of specified element
19185inline u64 algo::ary_rowid_Get(algo::U64Ary& parent, u64 &elem) {
19186    u64 id = &elem - parent.ary_elems;
19187    return u64(id);
19188}
19189
19190// --- algo.U64Ary.ary_curs.Next
19191// proceed to next item
19192inline void algo::U64Ary_ary_curs_Next(U64Ary_ary_curs &curs) {
19193    curs.index++;
19194}
19195
19196// --- algo.U64Ary.ary_curs.Reset
19197inline void algo::U64Ary_ary_curs_Reset(U64Ary_ary_curs &curs, algo::U64Ary &parent) {
19198    curs.elems = parent.ary_elems;
19199    curs.n_elems = parent.ary_n;
19200    curs.index = 0;
19201}
19202
19203// --- algo.U64Ary.ary_curs.ValidQ
19204// cursor points to valid item
19205inline bool algo::U64Ary_ary_curs_ValidQ(U64Ary_ary_curs &curs) {
19206    return curs.index < curs.n_elems;
19207}
19208
19209// --- algo.U64Ary.ary_curs.Access
19210// item access
19211inline u64& algo::U64Ary_ary_curs_Access(U64Ary_ary_curs &curs) {
19212    return curs.elems[curs.index];
19213}
19214
19215// --- algo.U64Ary..Init
19216// Set all fields to initial values.
19217inline void algo::U64Ary_Init(algo::U64Ary& parent) {
19218    parent.ary_elems 	= 0; // (algo.U64Ary.ary)
19219    parent.ary_n     	= 0; // (algo.U64Ary.ary)
19220    parent.ary_max   	= 0; // (algo.U64Ary.ary)
19221}
19222inline algo::U64Dec10::U64Dec10(u64                            in_value)
19223    : value(in_value)
19224{
19225}
19226inline algo::U64Dec10::U64Dec10() {
19227    algo::U64Dec10_Init(*this);
19228}
19229
19230
19231// --- algo.U64Dec10.value.qSetDouble
19232// Set value of field value.
19233// The value is rounded to the nearest integer.
19234// This ensures that truncation of a near-integer value does not occur.
19235// Example: 1.3 cannot be represented exactly as a double, the actual
19236// stored value will be 1.29999999. when we apply C truncation,
19237// we want to end up with 1.3, not 1.2.
19238inline void algo::value_qSetDouble(algo::U64Dec10& parent, double val) {
19239    double intval = val * 10000000000 + (val > 0 ? 0.5 : -0.5);
19240    // set underlying field.
19241    parent.value = intval;
19242}
19243
19244// --- algo.U64Dec10.value.GetDouble
19245inline double algo::value_GetDouble(const algo::U64Dec10& parent) {
19246    double ret;
19247    ret = parent.value / double(10000000000);
19248    return ret;
19249}
19250
19251// --- algo.U64Dec10.value.GetInt
19252// Return integer portion (divide number by 10000000000)
19253inline u64 algo::value_GetInt(const algo::U64Dec10& parent) {
19254    u64 ret;
19255    ret = parent.value / 10000000000;
19256    return ret;
19257}
19258
19259// --- algo.U64Dec10.value.GetScale
19260// Return constant 10000000000
19261inline u64 algo::U64Dec10_GetScale() {
19262    return 10000000000;
19263}
19264
19265// --- algo.U64Dec10.value.Cast
19266inline algo::U64Dec10::operator u64 () const {
19267    return u64((*this).value);
19268}
19269
19270// --- algo.U64Dec10..Hash
19271inline u32 algo::U64Dec10_Hash(u32 prev, algo::U64Dec10 rhs) {
19272    prev = u64_Hash(prev, rhs.value);
19273    return prev;
19274}
19275
19276// --- algo.U64Dec10..Init
19277// Set all fields to initial values.
19278inline void algo::U64Dec10_Init(algo::U64Dec10& parent) {
19279    parent.value = u64(0);
19280}
19281inline algo::U64Dec2::U64Dec2(u64                            in_value)
19282    : value(in_value)
19283{
19284}
19285inline algo::U64Dec2::U64Dec2() {
19286    algo::U64Dec2_Init(*this);
19287}
19288
19289
19290// --- algo.U64Dec2.value.qSetDouble
19291// Set value of field value.
19292// The value is rounded to the nearest integer.
19293// This ensures that truncation of a near-integer value does not occur.
19294// Example: 1.3 cannot be represented exactly as a double, the actual
19295// stored value will be 1.29999999. when we apply C truncation,
19296// we want to end up with 1.3, not 1.2.
19297inline void algo::value_qSetDouble(algo::U64Dec2& parent, double val) {
19298    double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
19299    // set underlying field.
19300    parent.value = intval;
19301}
19302
19303// --- algo.U64Dec2.value.GetDouble
19304inline double algo::value_GetDouble(const algo::U64Dec2& parent) {
19305    double ret;
19306    ret = parent.value / double(100);
19307    return ret;
19308}
19309
19310// --- algo.U64Dec2.value.GetInt
19311// Return integer portion (divide number by 100)
19312inline u64 algo::value_GetInt(const algo::U64Dec2& parent) {
19313    u64 ret;
19314    ret = parent.value / 100;
19315    return ret;
19316}
19317
19318// --- algo.U64Dec2.value.GetScale
19319// Return constant 100
19320inline u64 algo::U64Dec2_GetScale() {
19321    return 100;
19322}
19323
19324// --- algo.U64Dec2.value.Cast
19325inline algo::U64Dec2::operator u64 () const {
19326    return u64((*this).value);
19327}
19328
19329// --- algo.U64Dec2..Hash
19330inline u32 algo::U64Dec2_Hash(u32 prev, algo::U64Dec2 rhs) {
19331    prev = u64_Hash(prev, rhs.value);
19332    return prev;
19333}
19334
19335// --- algo.U64Dec2..Init
19336// Set all fields to initial values.
19337inline void algo::U64Dec2_Init(algo::U64Dec2& parent) {
19338    parent.value = u64(0);
19339}
19340inline algo::U64Dec4::U64Dec4(u64                            in_value)
19341    : value(in_value)
19342{
19343}
19344inline algo::U64Dec4::U64Dec4() {
19345    algo::U64Dec4_Init(*this);
19346}
19347
19348
19349// --- algo.U64Dec4.value.qSetDouble
19350// Set value of field value.
19351// The value is rounded to the nearest integer.
19352// This ensures that truncation of a near-integer value does not occur.
19353// Example: 1.3 cannot be represented exactly as a double, the actual
19354// stored value will be 1.29999999. when we apply C truncation,
19355// we want to end up with 1.3, not 1.2.
19356inline void algo::value_qSetDouble(algo::U64Dec4& parent, double val) {
19357    double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
19358    // set underlying field.
19359    parent.value = intval;
19360}
19361
19362// --- algo.U64Dec4.value.GetDouble
19363inline double algo::value_GetDouble(const algo::U64Dec4& parent) {
19364    double ret;
19365    ret = parent.value / double(10000);
19366    return ret;
19367}
19368
19369// --- algo.U64Dec4.value.GetInt
19370// Return integer portion (divide number by 10000)
19371inline u64 algo::value_GetInt(const algo::U64Dec4& parent) {
19372    u64 ret;
19373    ret = parent.value / 10000;
19374    return ret;
19375}
19376
19377// --- algo.U64Dec4.value.GetScale
19378// Return constant 10000
19379inline u64 algo::U64Dec4_GetScale() {
19380    return 10000;
19381}
19382
19383// --- algo.U64Dec4.value.Cast
19384inline algo::U64Dec4::operator u64 () const {
19385    return u64((*this).value);
19386}
19387
19388// --- algo.U64Dec4..Hash
19389inline u32 algo::U64Dec4_Hash(u32 prev, algo::U64Dec4 rhs) {
19390    prev = u64_Hash(prev, rhs.value);
19391    return prev;
19392}
19393
19394// --- algo.U64Dec4..Init
19395// Set all fields to initial values.
19396inline void algo::U64Dec4_Init(algo::U64Dec4& parent) {
19397    parent.value = u64(0);
19398}
19399inline algo::U64Dec5::U64Dec5(u64                            in_value)
19400    : value(in_value)
19401{
19402}
19403inline algo::U64Dec5::U64Dec5() {
19404    algo::U64Dec5_Init(*this);
19405}
19406
19407
19408// --- algo.U64Dec5.value.qSetDouble
19409// Set value of field value.
19410// The value is rounded to the nearest integer.
19411// This ensures that truncation of a near-integer value does not occur.
19412// Example: 1.3 cannot be represented exactly as a double, the actual
19413// stored value will be 1.29999999. when we apply C truncation,
19414// we want to end up with 1.3, not 1.2.
19415inline void algo::value_qSetDouble(algo::U64Dec5& parent, double val) {
19416    double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
19417    // set underlying field.
19418    parent.value = intval;
19419}
19420
19421// --- algo.U64Dec5.value.GetDouble
19422inline double algo::value_GetDouble(const algo::U64Dec5& parent) {
19423    double ret;
19424    ret = parent.value / double(100000);
19425    return ret;
19426}
19427
19428// --- algo.U64Dec5.value.GetInt
19429// Return integer portion (divide number by 100000)
19430inline u64 algo::value_GetInt(const algo::U64Dec5& parent) {
19431    u64 ret;
19432    ret = parent.value / 100000;
19433    return ret;
19434}
19435
19436// --- algo.U64Dec5.value.GetScale
19437// Return constant 100000
19438inline u64 algo::U64Dec5_GetScale() {
19439    return 100000;
19440}
19441
19442// --- algo.U64Dec5.value.Cast
19443inline algo::U64Dec5::operator u64 () const {
19444    return u64((*this).value);
19445}
19446
19447// --- algo.U64Dec5..Hash
19448inline u32 algo::U64Dec5_Hash(u32 prev, algo::U64Dec5 rhs) {
19449    prev = u64_Hash(prev, rhs.value);
19450    return prev;
19451}
19452
19453// --- algo.U64Dec5..Init
19454// Set all fields to initial values.
19455inline void algo::U64Dec5_Init(algo::U64Dec5& parent) {
19456    parent.value = u64(0);
19457}
19458inline algo::U64Dec6::U64Dec6(u64                            in_value)
19459    : value(in_value)
19460{
19461}
19462inline algo::U64Dec6::U64Dec6() {
19463    algo::U64Dec6_Init(*this);
19464}
19465
19466
19467// --- algo.U64Dec6.value.qSetDouble
19468// Set value of field value.
19469// The value is rounded to the nearest integer.
19470// This ensures that truncation of a near-integer value does not occur.
19471// Example: 1.3 cannot be represented exactly as a double, the actual
19472// stored value will be 1.29999999. when we apply C truncation,
19473// we want to end up with 1.3, not 1.2.
19474inline void algo::value_qSetDouble(algo::U64Dec6& parent, double val) {
19475    double intval = val * 1000000 + (val > 0 ? 0.5 : -0.5);
19476    // set underlying field.
19477    parent.value = intval;
19478}
19479
19480// --- algo.U64Dec6.value.GetDouble
19481inline double algo::value_GetDouble(const algo::U64Dec6& parent) {
19482    double ret;
19483    ret = parent.value / double(1000000);
19484    return ret;
19485}
19486
19487// --- algo.U64Dec6.value.GetInt
19488// Return integer portion (divide number by 1000000)
19489inline u64 algo::value_GetInt(const algo::U64Dec6& parent) {
19490    u64 ret;
19491    ret = parent.value / 1000000;
19492    return ret;
19493}
19494
19495// --- algo.U64Dec6.value.GetScale
19496// Return constant 1000000
19497inline u64 algo::U64Dec6_GetScale() {
19498    return 1000000;
19499}
19500
19501// --- algo.U64Dec6.value.Cast
19502inline algo::U64Dec6::operator u64 () const {
19503    return u64((*this).value);
19504}
19505
19506// --- algo.U64Dec6..Hash
19507inline u32 algo::U64Dec6_Hash(u32 prev, algo::U64Dec6 rhs) {
19508    prev = u64_Hash(prev, rhs.value);
19509    return prev;
19510}
19511
19512// --- algo.U64Dec6..Init
19513// Set all fields to initial values.
19514inline void algo::U64Dec6_Init(algo::U64Dec6& parent) {
19515    parent.value = u64(0);
19516}
19517inline algo::U64Dec7::U64Dec7(u64                            in_value)
19518    : value(in_value)
19519{
19520}
19521inline algo::U64Dec7::U64Dec7() {
19522    algo::U64Dec7_Init(*this);
19523}
19524
19525
19526// --- algo.U64Dec7.value.qSetDouble
19527// Set value of field value.
19528// The value is rounded to the nearest integer.
19529// This ensures that truncation of a near-integer value does not occur.
19530// Example: 1.3 cannot be represented exactly as a double, the actual
19531// stored value will be 1.29999999. when we apply C truncation,
19532// we want to end up with 1.3, not 1.2.
19533inline void algo::value_qSetDouble(algo::U64Dec7& parent, double val) {
19534    double intval = val * 10000000 + (val > 0 ? 0.5 : -0.5);
19535    // set underlying field.
19536    parent.value = intval;
19537}
19538
19539// --- algo.U64Dec7.value.GetDouble
19540inline double algo::value_GetDouble(const algo::U64Dec7& parent) {
19541    double ret;
19542    ret = parent.value / double(10000000);
19543    return ret;
19544}
19545
19546// --- algo.U64Dec7.value.GetInt
19547// Return integer portion (divide number by 10000000)
19548inline u64 algo::value_GetInt(const algo::U64Dec7& parent) {
19549    u64 ret;
19550    ret = parent.value / 10000000;
19551    return ret;
19552}
19553
19554// --- algo.U64Dec7.value.GetScale
19555// Return constant 10000000
19556inline u64 algo::U64Dec7_GetScale() {
19557    return 10000000;
19558}
19559
19560// --- algo.U64Dec7.value.Cast
19561inline algo::U64Dec7::operator u64 () const {
19562    return u64((*this).value);
19563}
19564
19565// --- algo.U64Dec7..Hash
19566inline u32 algo::U64Dec7_Hash(u32 prev, algo::U64Dec7 rhs) {
19567    prev = u64_Hash(prev, rhs.value);
19568    return prev;
19569}
19570
19571// --- algo.U64Dec7..Init
19572// Set all fields to initial values.
19573inline void algo::U64Dec7_Init(algo::U64Dec7& parent) {
19574    parent.value = u64(0);
19575}
19576inline algo::U64Dec8::U64Dec8(u64                            in_value)
19577    : value(in_value)
19578{
19579}
19580inline algo::U64Dec8::U64Dec8() {
19581    algo::U64Dec8_Init(*this);
19582}
19583
19584
19585// --- algo.U64Dec8.value.qSetDouble
19586// Set value of field value.
19587// The value is rounded to the nearest integer.
19588// This ensures that truncation of a near-integer value does not occur.
19589// Example: 1.3 cannot be represented exactly as a double, the actual
19590// stored value will be 1.29999999. when we apply C truncation,
19591// we want to end up with 1.3, not 1.2.
19592inline void algo::value_qSetDouble(algo::U64Dec8& parent, double val) {
19593    double intval = val * 100000000 + (val > 0 ? 0.5 : -0.5);
19594    // set underlying field.
19595    parent.value = intval;
19596}
19597
19598// --- algo.U64Dec8.value.GetDouble
19599inline double algo::value_GetDouble(const algo::U64Dec8& parent) {
19600    double ret;
19601    ret = parent.value / double(100000000);
19602    return ret;
19603}
19604
19605// --- algo.U64Dec8.value.GetInt
19606// Return integer portion (divide number by 100000000)
19607inline u64 algo::value_GetInt(const algo::U64Dec8& parent) {
19608    u64 ret;
19609    ret = parent.value / 100000000;
19610    return ret;
19611}
19612
19613// --- algo.U64Dec8.value.GetScale
19614// Return constant 100000000
19615inline u64 algo::U64Dec8_GetScale() {
19616    return 100000000;
19617}
19618
19619// --- algo.U64Dec8..Hash
19620inline u32 algo::U64Dec8_Hash(u32 prev, algo::U64Dec8 rhs) {
19621    prev = u64_Hash(prev, rhs.value);
19622    return prev;
19623}
19624
19625// --- algo.U64Dec8..Init
19626// Set all fields to initial values.
19627inline void algo::U64Dec8_Init(algo::U64Dec8& parent) {
19628    parent.value = u64(0);
19629}
19630inline algo::U64Dec9::U64Dec9(u64                            in_value)
19631    : value(in_value)
19632{
19633}
19634inline algo::U64Dec9::U64Dec9() {
19635    algo::U64Dec9_Init(*this);
19636}
19637
19638
19639// --- algo.U64Dec9.value.qSetDouble
19640// Set value of field value.
19641// The value is rounded to the nearest integer.
19642// This ensures that truncation of a near-integer value does not occur.
19643// Example: 1.3 cannot be represented exactly as a double, the actual
19644// stored value will be 1.29999999. when we apply C truncation,
19645// we want to end up with 1.3, not 1.2.
19646inline void algo::value_qSetDouble(algo::U64Dec9& parent, double val) {
19647    double intval = val * 1000000000 + (val > 0 ? 0.5 : -0.5);
19648    // set underlying field.
19649    parent.value = intval;
19650}
19651
19652// --- algo.U64Dec9.value.GetDouble
19653inline double algo::value_GetDouble(const algo::U64Dec9& parent) {
19654    double ret;
19655    ret = parent.value / double(1000000000);
19656    return ret;
19657}
19658
19659// --- algo.U64Dec9.value.GetInt
19660// Return integer portion (divide number by 1000000000)
19661inline u64 algo::value_GetInt(const algo::U64Dec9& parent) {
19662    u64 ret;
19663    ret = parent.value / 1000000000;
19664    return ret;
19665}
19666
19667// --- algo.U64Dec9.value.GetScale
19668// Return constant 1000000000
19669inline u64 algo::U64Dec9_GetScale() {
19670    return 1000000000;
19671}
19672
19673// --- algo.U64Dec9.value.Cast
19674inline algo::U64Dec9::operator u64 () const {
19675    return u64((*this).value);
19676}
19677
19678// --- algo.U64Dec9..Hash
19679inline u32 algo::U64Dec9_Hash(u32 prev, algo::U64Dec9 rhs) {
19680    prev = u64_Hash(prev, rhs.value);
19681    return prev;
19682}
19683
19684// --- algo.U64Dec9..Init
19685// Set all fields to initial values.
19686inline void algo::U64Dec9_Init(algo::U64Dec9& parent) {
19687    parent.value = u64(0);
19688}
19689inline algo::URL::URL(const algo::strptr&            in_protocol
19690        ,const algo::strptr&            in_username
19691        ,const algo::strptr&            in_password
19692        ,const algo::strptr&            in_server
19693        ,const algo::strptr&            in_dir
19694        ,i32                            in_port
19695        ,u32                            in_source_addr_host
19696        ,const algo::strptr&            in_host)
19697    : protocol(in_protocol)
19698    , username(in_username)
19699    , password(in_password)
19700    , server(in_server)
19701    , dir(in_dir)
19702    , port(in_port)
19703    , source_addr_host(in_source_addr_host)
19704    , host(in_host)
19705{
19706}
19707inline algo::URL::URL() {
19708    algo::URL_Init(*this);
19709}
19710
19711
19712// --- algo.URL..Init
19713// Set all fields to initial values.
19714inline void algo::URL_Init(algo::URL& parent) {
19715    parent.port = i32(-1);
19716    parent.source_addr_host = u32(0);
19717}
19718inline algo::UnDiff::UnDiff(i64                            in_value)
19719    : value(in_value)
19720{
19721}
19722
19723inline bool algo::UnDiff::operator ==(const algo::UnDiff &rhs) const {
19724    return algo::UnDiff_Eq(const_cast<algo::UnDiff&>(*this),const_cast<algo::UnDiff&>(rhs));
19725}
19726
19727inline bool algo::UnDiff::operator !=(const algo::UnDiff &rhs) const {
19728    return !algo::UnDiff_Eq(const_cast<algo::UnDiff&>(*this),const_cast<algo::UnDiff&>(rhs));
19729}
19730
19731inline bool algo::UnDiff::operator <(const algo::UnDiff &rhs) const {
19732    return algo::UnDiff_Lt(const_cast<algo::UnDiff&>(*this),const_cast<algo::UnDiff&>(rhs));
19733}
19734
19735inline bool algo::UnDiff::operator >(const algo::UnDiff &rhs) const {
19736    return rhs < *this;
19737}
19738
19739inline bool algo::UnDiff::operator <=(const algo::UnDiff &rhs) const {
19740    return !(rhs < *this);
19741}
19742
19743inline bool algo::UnDiff::operator >=(const algo::UnDiff &rhs) const {
19744    return !(*this < rhs);
19745}
19746inline algo::UnDiff::UnDiff() {
19747    algo::UnDiff_Init(*this);
19748}
19749
19750
19751// --- algo.UnDiff..Hash
19752inline u32 algo::UnDiff_Hash(u32 prev, algo::UnDiff rhs) {
19753    prev = i64_Hash(prev, rhs.value);
19754    return prev;
19755}
19756
19757// --- algo.UnDiff..Lt
19758inline bool algo::UnDiff_Lt(algo::UnDiff lhs, algo::UnDiff rhs) {
19759    return i64_Lt(lhs.value, rhs.value);
19760}
19761
19762// --- algo.UnDiff..Cmp
19763inline i32 algo::UnDiff_Cmp(algo::UnDiff lhs, algo::UnDiff rhs) {
19764    i32 retval = 0;
19765    retval = i64_Cmp(lhs.value, rhs.value);
19766    return retval;
19767}
19768
19769// --- algo.UnDiff..Init
19770// Set all fields to initial values.
19771inline void algo::UnDiff_Init(algo::UnDiff& parent) {
19772    parent.value = i64(0);
19773}
19774
19775// --- algo.UnDiff..UpdateMax
19776// Attempt to make LHS bigger. Return true if it was changed
19777inline bool algo::UnDiff_UpdateMax(algo::UnDiff &lhs, algo::UnDiff rhs) {
19778    bool retval = lhs < rhs;
19779    if (retval) {
19780        lhs = rhs;
19781    }
19782    return retval;
19783}
19784
19785// --- algo.UnDiff..Min
19786// Return the lesser of two values
19787inline algo::UnDiff algo::UnDiff_Min(algo::UnDiff lhs, algo::UnDiff rhs) {
19788    return lhs < rhs ? lhs : rhs;
19789}
19790
19791// --- algo.UnDiff..UpdateMin
19792// Attempt to make LHS smaller. Return true if it was changed
19793inline bool algo::UnDiff_UpdateMin(algo::UnDiff &lhs, algo::UnDiff rhs) {
19794    bool retval = rhs < lhs;
19795    if (retval) {
19796        lhs = rhs;
19797    }
19798    return retval;
19799}
19800
19801// --- algo.UnDiff..Max
19802// Return the greater of two values
19803inline algo::UnDiff algo::UnDiff_Max(algo::UnDiff lhs, algo::UnDiff rhs) {
19804    return rhs < lhs ? lhs : rhs;
19805}
19806
19807// --- algo.UnDiff..Eq
19808inline bool algo::UnDiff_Eq(algo::UnDiff lhs, algo::UnDiff rhs) {
19809    bool retval = true;
19810    retval = i64_Eq(lhs.value, rhs.value);
19811    return retval;
19812}
19813
19814// --- algo.UnDiff..Update
19815// Set value. Return true if new value is different from old value.
19816inline bool algo::UnDiff_Update(algo::UnDiff &lhs, algo::UnDiff rhs) {
19817    bool ret = !UnDiff_Eq(lhs, rhs); // compare values
19818    if (ret) {
19819        lhs = rhs; // update
19820    }
19821    return ret;
19822}
19823inline algo::UnixDiff::UnixDiff(i64                            in_value)
19824    : value(in_value)
19825{
19826}
19827
19828inline bool algo::UnixDiff::operator ==(const algo::UnixDiff &rhs) const {
19829    return algo::UnixDiff_Eq(const_cast<algo::UnixDiff&>(*this),const_cast<algo::UnixDiff&>(rhs));
19830}
19831
19832inline bool algo::UnixDiff::operator !=(const algo::UnixDiff &rhs) const {
19833    return !algo::UnixDiff_Eq(const_cast<algo::UnixDiff&>(*this),const_cast<algo::UnixDiff&>(rhs));
19834}
19835
19836inline bool algo::UnixDiff::operator <(const algo::UnixDiff &rhs) const {
19837    return algo::UnixDiff_Lt(const_cast<algo::UnixDiff&>(*this),const_cast<algo::UnixDiff&>(rhs));
19838}
19839
19840inline bool algo::UnixDiff::operator >(const algo::UnixDiff &rhs) const {
19841    return rhs < *this;
19842}
19843
19844inline bool algo::UnixDiff::operator <=(const algo::UnixDiff &rhs) const {
19845    return !(rhs < *this);
19846}
19847
19848inline bool algo::UnixDiff::operator >=(const algo::UnixDiff &rhs) const {
19849    return !(*this < rhs);
19850}
19851inline algo::UnixDiff::UnixDiff() {
19852    algo::UnixDiff_Init(*this);
19853}
19854
19855
19856// --- algo.UnixDiff..Hash
19857inline u32 algo::UnixDiff_Hash(u32 prev, algo::UnixDiff rhs) {
19858    prev = i64_Hash(prev, rhs.value);
19859    return prev;
19860}
19861
19862// --- algo.UnixDiff..Lt
19863inline bool algo::UnixDiff_Lt(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19864    return i64_Lt(lhs.value, rhs.value);
19865}
19866
19867// --- algo.UnixDiff..Cmp
19868inline i32 algo::UnixDiff_Cmp(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19869    i32 retval = 0;
19870    retval = i64_Cmp(lhs.value, rhs.value);
19871    return retval;
19872}
19873
19874// --- algo.UnixDiff..Init
19875// Set all fields to initial values.
19876inline void algo::UnixDiff_Init(algo::UnixDiff& parent) {
19877    parent.value = i64(0);
19878}
19879
19880// --- algo.UnixDiff..UpdateMax
19881// Attempt to make LHS bigger. Return true if it was changed
19882inline bool algo::UnixDiff_UpdateMax(algo::UnixDiff &lhs, algo::UnixDiff rhs) {
19883    bool retval = lhs < rhs;
19884    if (retval) {
19885        lhs = rhs;
19886    }
19887    return retval;
19888}
19889
19890// --- algo.UnixDiff..Min
19891// Return the lesser of two values
19892inline algo::UnixDiff algo::UnixDiff_Min(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19893    return lhs < rhs ? lhs : rhs;
19894}
19895
19896// --- algo.UnixDiff..UpdateMin
19897// Attempt to make LHS smaller. Return true if it was changed
19898inline bool algo::UnixDiff_UpdateMin(algo::UnixDiff &lhs, algo::UnixDiff rhs) {
19899    bool retval = rhs < lhs;
19900    if (retval) {
19901        lhs = rhs;
19902    }
19903    return retval;
19904}
19905
19906// --- algo.UnixDiff..Max
19907// Return the greater of two values
19908inline algo::UnixDiff algo::UnixDiff_Max(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19909    return rhs < lhs ? lhs : rhs;
19910}
19911
19912// --- algo.UnixDiff..Eq
19913inline bool algo::UnixDiff_Eq(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19914    bool retval = true;
19915    retval = i64_Eq(lhs.value, rhs.value);
19916    return retval;
19917}
19918
19919// --- algo.UnixDiff..Update
19920// Set value. Return true if new value is different from old value.
19921inline bool algo::UnixDiff_Update(algo::UnixDiff &lhs, algo::UnixDiff rhs) {
19922    bool ret = !UnixDiff_Eq(lhs, rhs); // compare values
19923    if (ret) {
19924        lhs = rhs; // update
19925    }
19926    return ret;
19927}
19928inline algo::UnixTime::UnixTime(i64                            in_value)
19929    : value(in_value)
19930{
19931}
19932
19933inline bool algo::UnixTime::operator ==(const algo::UnixTime &rhs) const {
19934    return algo::UnixTime_Eq(const_cast<algo::UnixTime&>(*this),const_cast<algo::UnixTime&>(rhs));
19935}
19936
19937inline bool algo::UnixTime::operator !=(const algo::UnixTime &rhs) const {
19938    return !algo::UnixTime_Eq(const_cast<algo::UnixTime&>(*this),const_cast<algo::UnixTime&>(rhs));
19939}
19940
19941inline bool algo::UnixTime::operator <(const algo::UnixTime &rhs) const {
19942    return algo::UnixTime_Lt(const_cast<algo::UnixTime&>(*this),const_cast<algo::UnixTime&>(rhs));
19943}
19944
19945inline bool algo::UnixTime::operator >(const algo::UnixTime &rhs) const {
19946    return rhs < *this;
19947}
19948
19949inline bool algo::UnixTime::operator <=(const algo::UnixTime &rhs) const {
19950    return !(rhs < *this);
19951}
19952
19953inline bool algo::UnixTime::operator >=(const algo::UnixTime &rhs) const {
19954    return !(*this < rhs);
19955}
19956inline algo::UnixTime::UnixTime() {
19957    algo::UnixTime_Init(*this);
19958}
19959
19960
19961// --- algo.UnixTime..Hash
19962inline u32 algo::UnixTime_Hash(u32 prev, algo::UnixTime rhs) {
19963    prev = i64_Hash(prev, rhs.value);
19964    return prev;
19965}
19966
19967// --- algo.UnixTime..Lt
19968inline bool algo::UnixTime_Lt(algo::UnixTime lhs, algo::UnixTime rhs) {
19969    return i64_Lt(lhs.value, rhs.value);
19970}
19971
19972// --- algo.UnixTime..Cmp
19973inline i32 algo::UnixTime_Cmp(algo::UnixTime lhs, algo::UnixTime rhs) {
19974    i32 retval = 0;
19975    retval = i64_Cmp(lhs.value, rhs.value);
19976    return retval;
19977}
19978
19979// --- algo.UnixTime..Init
19980// Set all fields to initial values.
19981inline void algo::UnixTime_Init(algo::UnixTime& parent) {
19982    parent.value = i64(0);
19983}
19984
19985// --- algo.UnixTime..UpdateMax
19986// Attempt to make LHS bigger. Return true if it was changed
19987inline bool algo::UnixTime_UpdateMax(algo::UnixTime &lhs, algo::UnixTime rhs) {
19988    bool retval = lhs < rhs;
19989    if (retval) {
19990        lhs = rhs;
19991    }
19992    return retval;
19993}
19994
19995// --- algo.UnixTime..Min
19996// Return the lesser of two values
19997inline algo::UnixTime algo::UnixTime_Min(algo::UnixTime lhs, algo::UnixTime rhs) {
19998    return lhs < rhs ? lhs : rhs;
19999}
20000
20001// --- algo.UnixTime..UpdateMin
20002// Attempt to make LHS smaller. Return true if it was changed
20003inline bool algo::UnixTime_UpdateMin(algo::UnixTime &lhs, algo::UnixTime rhs) {
20004    bool retval = rhs < lhs;
20005    if (retval) {
20006        lhs = rhs;
20007    }
20008    return retval;
20009}
20010
20011// --- algo.UnixTime..Max
20012// Return the greater of two values
20013inline algo::UnixTime algo::UnixTime_Max(algo::UnixTime lhs, algo::UnixTime rhs) {
20014    return rhs < lhs ? lhs : rhs;
20015}
20016
20017// --- algo.UnixTime..Eq
20018inline bool algo::UnixTime_Eq(algo::UnixTime lhs, algo::UnixTime rhs) {
20019    bool retval = true;
20020    retval = i64_Eq(lhs.value, rhs.value);
20021    return retval;
20022}
20023
20024// --- algo.UnixTime..Update
20025// Set value. Return true if new value is different from old value.
20026inline bool algo::UnixTime_Update(algo::UnixTime &lhs, algo::UnixTime rhs) {
20027    bool ret = !UnixTime_Eq(lhs, rhs); // compare values
20028    if (ret) {
20029        lhs = rhs; // update
20030    }
20031    return ret;
20032}
20033inline algo::WDiff::WDiff(i64                            in_value)
20034    : value(in_value)
20035{
20036}
20037
20038inline bool algo::WDiff::operator ==(const algo::WDiff &rhs) const {
20039    return algo::WDiff_Eq(const_cast<algo::WDiff&>(*this),const_cast<algo::WDiff&>(rhs));
20040}
20041
20042inline bool algo::WDiff::operator !=(const algo::WDiff &rhs) const {
20043    return !algo::WDiff_Eq(const_cast<algo::WDiff&>(*this),const_cast<algo::WDiff&>(rhs));
20044}
20045
20046inline bool algo::WDiff::operator <(const algo::WDiff &rhs) const {
20047    return algo::WDiff_Lt(const_cast<algo::WDiff&>(*this),const_cast<algo::WDiff&>(rhs));
20048}
20049
20050inline bool algo::WDiff::operator >(const algo::WDiff &rhs) const {
20051    return rhs < *this;
20052}
20053
20054inline bool algo::WDiff::operator <=(const algo::WDiff &rhs) const {
20055    return !(rhs < *this);
20056}
20057
20058inline bool algo::WDiff::operator >=(const algo::WDiff &rhs) const {
20059    return !(*this < rhs);
20060}
20061inline algo::WDiff::WDiff() {
20062    algo::WDiff_Init(*this);
20063}
20064
20065
20066// --- algo.WDiff..Hash
20067inline u32 algo::WDiff_Hash(u32 prev, algo::WDiff rhs) {
20068    prev = i64_Hash(prev, rhs.value);
20069    return prev;
20070}
20071
20072// --- algo.WDiff..Lt
20073inline bool algo::WDiff_Lt(algo::WDiff lhs, algo::WDiff rhs) {
20074    return i64_Lt(lhs.value, rhs.value);
20075}
20076
20077// --- algo.WDiff..Cmp
20078inline i32 algo::WDiff_Cmp(algo::WDiff lhs, algo::WDiff rhs) {
20079    i32 retval = 0;
20080    retval = i64_Cmp(lhs.value, rhs.value);
20081    return retval;
20082}
20083
20084// --- algo.WDiff..Init
20085// Set all fields to initial values.
20086inline void algo::WDiff_Init(algo::WDiff& parent) {
20087    parent.value = i64(0);
20088}
20089
20090// --- algo.WDiff..UpdateMax
20091// Attempt to make LHS bigger. Return true if it was changed
20092inline bool algo::WDiff_UpdateMax(algo::WDiff &lhs, algo::WDiff rhs) {
20093    bool retval = lhs < rhs;
20094    if (retval) {
20095        lhs = rhs;
20096    }
20097    return retval;
20098}
20099
20100// --- algo.WDiff..Min
20101// Return the lesser of two values
20102inline algo::WDiff algo::WDiff_Min(algo::WDiff lhs, algo::WDiff rhs) {
20103    return lhs < rhs ? lhs : rhs;
20104}
20105
20106// --- algo.WDiff..UpdateMin
20107// Attempt to make LHS smaller. Return true if it was changed
20108inline bool algo::WDiff_UpdateMin(algo::WDiff &lhs, algo::WDiff rhs) {
20109    bool retval = rhs < lhs;
20110    if (retval) {
20111        lhs = rhs;
20112    }
20113    return retval;
20114}
20115
20116// --- algo.WDiff..Max
20117// Return the greater of two values
20118inline algo::WDiff algo::WDiff_Max(algo::WDiff lhs, algo::WDiff rhs) {
20119    return rhs < lhs ? lhs : rhs;
20120}
20121
20122// --- algo.WDiff..Eq
20123inline bool algo::WDiff_Eq(algo::WDiff lhs, algo::WDiff rhs) {
20124    bool retval = true;
20125    retval = i64_Eq(lhs.value, rhs.value);
20126    return retval;
20127}
20128
20129// --- algo.WDiff..Update
20130// Set value. Return true if new value is different from old value.
20131inline bool algo::WDiff_Update(algo::WDiff &lhs, algo::WDiff rhs) {
20132    bool ret = !WDiff_Eq(lhs, rhs); // compare values
20133    if (ret) {
20134        lhs = rhs; // update
20135    }
20136    return ret;
20137}
20138inline algo::WTime::WTime(i64                            in_value)
20139    : value(in_value)
20140{
20141}
20142
20143inline bool algo::WTime::operator ==(const algo::WTime &rhs) const {
20144    return algo::WTime_Eq(const_cast<algo::WTime&>(*this),const_cast<algo::WTime&>(rhs));
20145}
20146
20147inline bool algo::WTime::operator !=(const algo::WTime &rhs) const {
20148    return !algo::WTime_Eq(const_cast<algo::WTime&>(*this),const_cast<algo::WTime&>(rhs));
20149}
20150
20151inline bool algo::WTime::operator <(const algo::WTime &rhs) const {
20152    return algo::WTime_Lt(const_cast<algo::WTime&>(*this),const_cast<algo::WTime&>(rhs));
20153}
20154
20155inline bool algo::WTime::operator >(const algo::WTime &rhs) const {
20156    return rhs < *this;
20157}
20158
20159inline bool algo::WTime::operator <=(const algo::WTime &rhs) const {
20160    return !(rhs < *this);
20161}
20162
20163inline bool algo::WTime::operator >=(const algo::WTime &rhs) const {
20164    return !(*this < rhs);
20165}
20166inline algo::WTime::WTime() {
20167    algo::WTime_Init(*this);
20168}
20169
20170
20171// --- algo.WTime..Hash
20172inline u32 algo::WTime_Hash(u32 prev, algo::WTime rhs) {
20173    prev = i64_Hash(prev, rhs.value);
20174    return prev;
20175}
20176
20177// --- algo.WTime..Lt
20178inline bool algo::WTime_Lt(algo::WTime lhs, algo::WTime rhs) {
20179    return i64_Lt(lhs.value, rhs.value);
20180}
20181
20182// --- algo.WTime..Cmp
20183inline i32 algo::WTime_Cmp(algo::WTime lhs, algo::WTime rhs) {
20184    i32 retval = 0;
20185    retval = i64_Cmp(lhs.value, rhs.value);
20186    return retval;
20187}
20188
20189// --- algo.WTime..Init
20190// Set all fields to initial values.
20191inline void algo::WTime_Init(algo::WTime& parent) {
20192    parent.value = i64(0);
20193}
20194
20195// --- algo.WTime..UpdateMax
20196// Attempt to make LHS bigger. Return true if it was changed
20197inline bool algo::WTime_UpdateMax(algo::WTime &lhs, algo::WTime rhs) {
20198    bool retval = lhs < rhs;
20199    if (retval) {
20200        lhs = rhs;
20201    }
20202    return retval;
20203}
20204
20205// --- algo.WTime..Min
20206// Return the lesser of two values
20207inline algo::WTime algo::WTime_Min(algo::WTime lhs, algo::WTime rhs) {
20208    return lhs < rhs ? lhs : rhs;
20209}
20210
20211// --- algo.WTime..UpdateMin
20212// Attempt to make LHS smaller. Return true if it was changed
20213inline bool algo::WTime_UpdateMin(algo::WTime &lhs, algo::WTime rhs) {
20214    bool retval = rhs < lhs;
20215    if (retval) {
20216        lhs = rhs;
20217    }
20218    return retval;
20219}
20220
20221// --- algo.WTime..Max
20222// Return the greater of two values
20223inline algo::WTime algo::WTime_Max(algo::WTime lhs, algo::WTime rhs) {
20224    return rhs < lhs ? lhs : rhs;
20225}
20226
20227// --- algo.WTime..Eq
20228inline bool algo::WTime_Eq(algo::WTime lhs, algo::WTime rhs) {
20229    bool retval = true;
20230    retval = i64_Eq(lhs.value, rhs.value);
20231    return retval;
20232}
20233
20234// --- algo.WTime..Update
20235// Set value. Return true if new value is different from old value.
20236inline bool algo::WTime_Update(algo::WTime &lhs, algo::WTime rhs) {
20237    bool ret = !WTime_Eq(lhs, rhs); // compare values
20238    if (ret) {
20239        lhs = rhs; // update
20240    }
20241    return ret;
20242}
20243inline algo::i32_Range::i32_Range(i32                            in_beg
20244        ,i32                            in_end)
20245    : beg(in_beg)
20246    , end(in_end)
20247{
20248}
20249
20250inline bool algo::i32_Range::operator ==(const algo::i32_Range &rhs) const {
20251    return algo::i32_Range_Eq(const_cast<algo::i32_Range&>(*this),const_cast<algo::i32_Range&>(rhs));
20252}
20253
20254inline bool algo::i32_Range::operator !=(const algo::i32_Range &rhs) const {
20255    return !algo::i32_Range_Eq(const_cast<algo::i32_Range&>(*this),const_cast<algo::i32_Range&>(rhs));
20256}
20257
20258inline bool algo::i32_Range::operator <(const algo::i32_Range &rhs) const {
20259    return algo::i32_Range_Lt(const_cast<algo::i32_Range&>(*this),const_cast<algo::i32_Range&>(rhs));
20260}
20261
20262inline bool algo::i32_Range::operator >(const algo::i32_Range &rhs) const {
20263    return rhs < *this;
20264}
20265
20266inline bool algo::i32_Range::operator <=(const algo::i32_Range &rhs) const {
20267    return !(rhs < *this);
20268}
20269
20270inline bool algo::i32_Range::operator >=(const algo::i32_Range &rhs) const {
20271    return !(*this < rhs);
20272}
20273inline algo::i32_Range::i32_Range() {
20274    algo::i32_Range_Init(*this);
20275}
20276
20277
20278// --- algo.i32_Range..Hash
20279inline u32 algo::i32_Range_Hash(u32 prev, const algo::i32_Range & rhs) {
20280    prev = i32_Hash(prev, rhs.beg);
20281    prev = i32_Hash(prev, rhs.end);
20282    return prev;
20283}
20284
20285// --- algo.i32_Range..Lt
20286inline bool algo::i32_Range_Lt(algo::i32_Range& lhs, algo::i32_Range& rhs) {
20287    return i32_Range_Cmp(lhs,rhs) < 0;
20288}
20289
20290// --- algo.i32_Range..Cmp
20291inline i32 algo::i32_Range_Cmp(algo::i32_Range& lhs, algo::i32_Range& rhs) {
20292    i32 retval = 0;
20293    retval = i32_Cmp(lhs.beg, rhs.beg);
20294    if (retval != 0) {
20295        return retval;
20296    }
20297    retval = i32_Cmp(lhs.end, rhs.end);
20298    return retval;
20299}
20300
20301// --- algo.i32_Range..Init
20302// Set all fields to initial values.
20303inline void algo::i32_Range_Init(algo::i32_Range& parent) {
20304    parent.beg = i32(0);
20305    parent.end = i32(0);
20306}
20307
20308// --- algo.i32_Range..Eq
20309inline bool algo::i32_Range_Eq(algo::i32_Range& lhs, algo::i32_Range& rhs) {
20310    bool retval = true;
20311    retval = i32_Eq(lhs.beg, rhs.beg);
20312    if (!retval) {
20313        return false;
20314    }
20315    retval = i32_Eq(lhs.end, rhs.end);
20316    return retval;
20317}
20318
20319// --- algo.i32_Range..Update
20320// Set value. Return true if new value is different from old value.
20321inline bool algo::i32_Range_Update(algo::i32_Range &lhs, algo::i32_Range& rhs) {
20322    bool ret = !i32_Range_Eq(lhs, rhs); // compare values
20323    if (ret) {
20324        lhs = rhs; // update
20325    }
20326    return ret;
20327}
20328
20329inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Attr &row) {// cfmt:algo.Attr.String
20330    algo::Attr_Print(const_cast<algo::Attr&>(row), str);
20331    return str;
20332}
20333
20334inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Bool &row) {// cfmt:algo.Bool.String
20335    algo::Bool_Print(const_cast<algo::Bool&>(row), str);
20336    return str;
20337}
20338
20339inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Comment &row) {// cfmt:algo.Comment.String
20340    algo::Comment_Print(const_cast<algo::Comment&>(row), str);
20341    return str;
20342}
20343
20344inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::CppExpr &row) {// cfmt:algo.CppExpr.String
20345    algo::CppExpr_Print(const_cast<algo::CppExpr&>(row), str);
20346    return str;
20347}
20348
20349inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnTime &row) {// cfmt:algo.UnTime.String
20350    algo::UnTime_Print(const_cast<algo::UnTime&>(row), str);
20351    return str;
20352}
20353
20354inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Decimal &row) {// cfmt:algo.Decimal.String
20355    algo::Decimal_Print(const_cast<algo::Decimal&>(row), str);
20356    return str;
20357}
20358
20359inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::DryrunQ &row) {// cfmt:algo.DryrunQ.String
20360    algo::DryrunQ_Print(const_cast<algo::DryrunQ&>(row), str);
20361    return str;
20362}
20363
20364inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::EchoQ &row) {// cfmt:algo.EchoQ.String
20365    algo::EchoQ_Print(const_cast<algo::EchoQ&>(row), str);
20366    return str;
20367}
20368
20369inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Errcode &row) {// cfmt:algo.Errcode.String
20370    algo::Errcode_Print(const_cast<algo::Errcode&>(row), str);
20371    return str;
20372}
20373
20374inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::FailokQ &row) {// cfmt:algo.FailokQ.String
20375    algo::FailokQ_Print(const_cast<algo::FailokQ&>(row), str);
20376    return str;
20377}
20378
20379inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::FieldId &row) {// cfmt:algo.FieldId.String
20380    algo::FieldId_Print(const_cast<algo::FieldId&>(row), str);
20381    return str;
20382}
20383
20384inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Fildes &row) {// cfmt:algo.Fildes.String
20385    algo::Fildes_Print(const_cast<algo::Fildes&>(row), str);
20386    return str;
20387}
20388
20389inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::FileFlags &row) {// cfmt:algo.FileFlags.String
20390    algo::FileFlags_Print(const_cast<algo::FileFlags&>(row), str);
20391    return str;
20392}
20393
20394inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec1 &row) {// cfmt:algo.I32Dec1.String
20395    algo::I32Dec1_Print(const_cast<algo::I32Dec1&>(row), str);
20396    return str;
20397}
20398
20399inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec2 &row) {// cfmt:algo.I32Dec2.String
20400    algo::I32Dec2_Print(const_cast<algo::I32Dec2&>(row), str);
20401    return str;
20402}
20403
20404inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec3 &row) {// cfmt:algo.I32Dec3.String
20405    algo::I32Dec3_Print(const_cast<algo::I32Dec3&>(row), str);
20406    return str;
20407}
20408
20409inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec4 &row) {// cfmt:algo.I32Dec4.String
20410    algo::I32Dec4_Print(const_cast<algo::I32Dec4&>(row), str);
20411    return str;
20412}
20413
20414inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec5 &row) {// cfmt:algo.I32Dec5.String
20415    algo::I32Dec5_Print(const_cast<algo::I32Dec5&>(row), str);
20416    return str;
20417}
20418
20419inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec1 &row) {// cfmt:algo.I64Dec1.String
20420    algo::I64Dec1_Print(const_cast<algo::I64Dec1&>(row), str);
20421    return str;
20422}
20423
20424inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec10 &row) {// cfmt:algo.I64Dec10.String
20425    algo::I64Dec10_Print(const_cast<algo::I64Dec10&>(row), str);
20426    return str;
20427}
20428
20429inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec2 &row) {// cfmt:algo.I64Dec2.String
20430    algo::I64Dec2_Print(const_cast<algo::I64Dec2&>(row), str);
20431    return str;
20432}
20433
20434inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec3 &row) {// cfmt:algo.I64Dec3.String
20435    algo::I64Dec3_Print(const_cast<algo::I64Dec3&>(row), str);
20436    return str;
20437}
20438
20439inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec4 &row) {// cfmt:algo.I64Dec4.String
20440    algo::I64Dec4_Print(const_cast<algo::I64Dec4&>(row), str);
20441    return str;
20442}
20443
20444inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec5 &row) {// cfmt:algo.I64Dec5.String
20445    algo::I64Dec5_Print(const_cast<algo::I64Dec5&>(row), str);
20446    return str;
20447}
20448
20449inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec6 &row) {// cfmt:algo.I64Dec6.String
20450    algo::I64Dec6_Print(const_cast<algo::I64Dec6&>(row), str);
20451    return str;
20452}
20453
20454inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec7 &row) {// cfmt:algo.I64Dec7.String
20455    algo::I64Dec7_Print(const_cast<algo::I64Dec7&>(row), str);
20456    return str;
20457}
20458
20459inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec8 &row) {// cfmt:algo.I64Dec8.String
20460    algo::I64Dec8_Print(const_cast<algo::I64Dec8&>(row), str);
20461    return str;
20462}
20463
20464inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec9 &row) {// cfmt:algo.I64Dec9.String
20465    algo::I64Dec9_Print(const_cast<algo::I64Dec9&>(row), str);
20466    return str;
20467}
20468
20469inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::IOEvtFlags &row) {// cfmt:algo.IOEvtFlags.String
20470    algo::IOEvtFlags_Print(const_cast<algo::IOEvtFlags&>(row), str);
20471    return str;
20472}
20473
20474inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Imdb &row) {// cfmt:algo.Imdb.String
20475    algo::Imdb_Print(const_cast<algo::Imdb&>(row), str);
20476    return str;
20477}
20478
20479inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::ImrowPtr &row) {// cfmt:algo.ImrowPtr.String
20480    algo::ImrowPtr_Print(const_cast<algo::ImrowPtr&>(row), str);
20481    return str;
20482}
20483
20484inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Imtable &row) {// cfmt:algo.Imtable.String
20485    algo::Imtable_Print(const_cast<algo::Imtable&>(row), str);
20486    return str;
20487}
20488
20489inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Ipmask &row) {// cfmt:algo.Ipmask.String
20490    algo::Ipmask_Print(const_cast<algo::Ipmask&>(row), str);
20491    return str;
20492}
20493
20494inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Md5Digest &row) {// cfmt:algo.Md5Digest.String
20495    algo::Md5Digest_Print(const_cast<algo::Md5Digest&>(row), str);
20496    return str;
20497}
20498
20499inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Month &row) {// cfmt:algo.Month.String
20500    algo::Month_Print(const_cast<algo::Month&>(row), str);
20501    return str;
20502}
20503
20504inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::NumParseFlags &row) {// cfmt:algo.NumParseFlags.String
20505    algo::NumParseFlags_Print(const_cast<algo::NumParseFlags&>(row), str);
20506    return str;
20507}
20508
20509inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::SchedTime &row) {// cfmt:algo.SchedTime.String
20510    algo::SchedTime_Print(const_cast<algo::SchedTime&>(row), str);
20511    return str;
20512}
20513
20514inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::SeqType &row) {// cfmt:algo.SeqType.String
20515    algo::SeqType_Print(const_cast<algo::SeqType&>(row), str);
20516    return str;
20517}
20518
20519inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Sha1sig &row) {// cfmt:algo.Sha1sig.String
20520    algo::Sha1sig_Print(const_cast<algo::Sha1sig&>(row), str);
20521    return str;
20522}
20523
20524inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::StringAry &row) {// cfmt:algo.StringAry.String
20525    algo::StringAry_Print(const_cast<algo::StringAry&>(row), str);
20526    return str;
20527}
20528
20529inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::TermStyle &row) {// cfmt:algo.TermStyle.String
20530    algo::TermStyle_Print(const_cast<algo::TermStyle&>(row), str);
20531    return str;
20532}
20533
20534inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::TextJust &row) {// cfmt:algo.TextJust.String
20535    algo::TextJust_Print(const_cast<algo::TextJust&>(row), str);
20536    return str;
20537}
20538
20539inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Tuple &row) {// cfmt:algo.Tuple.String
20540    algo::Tuple_Print(const_cast<algo::Tuple&>(row), str);
20541    return str;
20542}
20543
20544inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U16Dec2 &row) {// cfmt:algo.U16Dec2.String
20545    algo::U16Dec2_Print(const_cast<algo::U16Dec2&>(row), str);
20546    return str;
20547}
20548
20549inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec1 &row) {// cfmt:algo.U32Dec1.String
20550    algo::U32Dec1_Print(const_cast<algo::U32Dec1&>(row), str);
20551    return str;
20552}
20553
20554inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec2 &row) {// cfmt:algo.U32Dec2.String
20555    algo::U32Dec2_Print(const_cast<algo::U32Dec2&>(row), str);
20556    return str;
20557}
20558
20559inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec3 &row) {// cfmt:algo.U32Dec3.String
20560    algo::U32Dec3_Print(const_cast<algo::U32Dec3&>(row), str);
20561    return str;
20562}
20563
20564inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec4 &row) {// cfmt:algo.U32Dec4.String
20565    algo::U32Dec4_Print(const_cast<algo::U32Dec4&>(row), str);
20566    return str;
20567}
20568
20569inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec5 &row) {// cfmt:algo.U32Dec5.String
20570    algo::U32Dec5_Print(const_cast<algo::U32Dec5&>(row), str);
20571    return str;
20572}
20573
20574inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec10 &row) {// cfmt:algo.U64Dec10.String
20575    algo::U64Dec10_Print(const_cast<algo::U64Dec10&>(row), str);
20576    return str;
20577}
20578
20579inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec2 &row) {// cfmt:algo.U64Dec2.String
20580    algo::U64Dec2_Print(const_cast<algo::U64Dec2&>(row), str);
20581    return str;
20582}
20583
20584inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec4 &row) {// cfmt:algo.U64Dec4.String
20585    algo::U64Dec4_Print(const_cast<algo::U64Dec4&>(row), str);
20586    return str;
20587}
20588
20589inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec5 &row) {// cfmt:algo.U64Dec5.String
20590    algo::U64Dec5_Print(const_cast<algo::U64Dec5&>(row), str);
20591    return str;
20592}
20593
20594inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec6 &row) {// cfmt:algo.U64Dec6.String
20595    algo::U64Dec6_Print(const_cast<algo::U64Dec6&>(row), str);
20596    return str;
20597}
20598
20599inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec7 &row) {// cfmt:algo.U64Dec7.String
20600    algo::U64Dec7_Print(const_cast<algo::U64Dec7&>(row), str);
20601    return str;
20602}
20603
20604inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec8 &row) {// cfmt:algo.U64Dec8.String
20605    algo::U64Dec8_Print(const_cast<algo::U64Dec8&>(row), str);
20606    return str;
20607}
20608
20609inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec9 &row) {// cfmt:algo.U64Dec9.String
20610    algo::U64Dec9_Print(const_cast<algo::U64Dec9&>(row), str);
20611    return str;
20612}
20613
20614inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::URL &row) {// cfmt:algo.URL.String
20615    algo::URL_Print(const_cast<algo::URL&>(row), str);
20616    return str;
20617}
20618
20619inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnDiff &row) {// cfmt:algo.UnDiff.String
20620    algo::UnDiff_Print(const_cast<algo::UnDiff&>(row), str);
20621    return str;
20622}
20623
20624inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnixDiff &row) {// cfmt:algo.UnixDiff.String
20625    algo::UnixDiff_Print(const_cast<algo::UnixDiff&>(row), str);
20626    return str;
20627}
20628
20629inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnixTime &row) {// cfmt:algo.UnixTime.String
20630    algo::UnixTime_Print(const_cast<algo::UnixTime&>(row), str);
20631    return str;
20632}
20633
20634inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::WDiff &row) {// cfmt:algo.WDiff.String
20635    algo::WDiff_Print(const_cast<algo::WDiff&>(row), str);
20636    return str;
20637}
20638
20639inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::WTime &row) {// cfmt:algo.WTime.String
20640    algo::WTime_Print(const_cast<algo::WTime&>(row), str);
20641    return str;
20642}
20643
20644inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::i32_Range &row) {// cfmt:algo.i32_Range.String
20645    algo::i32_Range_Print(const_cast<algo::i32_Range&>(row), str);
20646    return str;
20647}